Games of Daze/Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso/x2ftp/msdos/faq/prolog.127

Internet Message Format | 1995-04-20 | 163.3 KB

Path: senator-bedfellow.mit.edu!bloom-beacon.mit.edu!uhog.mit.edu!nntp.club.cc.cmu.edu!cantaloupe.srv.cs.cmu.edu!mkant
From: [e-mail] (Mark Kantrowitz)
Newsgroups: comp.lang.prolog,comp.object.logic,news.answers,comp.answers
Subject: FAQ: Prolog Resource Guide 1/2 [Monthly posting]
Supersedes: <[e-mail]>
Followup-To: poster
Date: 13 Mar 1995 08:02:50 GMT
Organization: School of Computer Science, Carnegie Mellon University
Lines: 1700
Approved: [e-mail]
Distribution: world
Expires: 24 Apr 1995 08:00:33 GMT
Message-ID: <[e-mail]>
Reply-To: [e-mail]
NNTP-Posting-Host: glinda.oz.cs.cmu.edu
Xref: senator-bedfellow.mit.edu comp.lang.prolog:12370 comp.object.logic:388 news.answers:39806 comp.answers:10628

Archive-name: prolog/resource-guide/part1
Last-Modified: Fri Mar 10 16:35:04 1995 by Mark Kantrowitz
Version: 1.27
Maintainer: Mark Kantrowitz <[e-mail]>
URL: http://www.cs.cmu.edu:8001/Web/Groups/AI/html/faqs/lang/prolog/prg/top.html
Size: 81042 bytes, 1708 lines

;;; ****************************************************************
;;; Prolog Resource Guide ******************************************
;;; ****************************************************************
;;; prg_1.faq

This post contains the Prolog Resource Guide.

Contributions, corrections, suggestions, and comments should be sent
to Mark Kantrowitz <[e-mail]>.

This guide lists a variety of resources for the Prolog community,
including books, magazines, ftp archives, and products. It is posted
on the 13th of every month to the newsgroups comp.lang.prolog and
comp.object.logic. The PRG is also posted to the newsgroups
news.answers and comp.answers where they should be available at any
time (ask your local news manager).

*** Copyright:

Copyright (c) 1992-94 by Mark Kantrowitz. All rights reserved.

This FAQ may be freely redistributed in its entirety without
modification provided that this copyright notice is not removed.  It
may not be sold for profit or incorporated in commercial documents
(e.g., published for sale on CD-ROM, floppy disks, books, magazines,
or other print form) without the prior written permission of the
copyright holder.  Permission is expressly granted for this document
to be made available for file transfer from installations offering
unrestricted anonymous file transfer on the Internet.

If this FAQ is reproduced in offline media (e.g., CD-ROM, print form,
etc.), a complimentary copy should be sent to Mark Kantrowitz, School
of Computer Science, Carnegie Mellon University, 5000 Forbes Avenue,
Pittsburgh, PA 15213-3891 USA.

This article is provided AS IS without any express or implied warranty.

*** Recent Changes:

;;; 1.24:
;;; 13-OCT-94 mk    Added Hdrug to [1-5].
;;; 13-OCT-94 mk    Added FW_Rules to [1-5].
;;; 14-OCT-94 mk    Added KLIC entry and removed PDSS entry in [2-3].
;;; 14-OCT-94 mk    Updated Quintus entry in [2-2].
;;; 20-OCT-94 mk    Updated prices for books by Dennis Merritt of Amzi! Inc.
;;; 20-OCT-94 mk    Added entry on GT-Prolog (prolog for Amiga) to [2-2].
;;; 28-OCT-94 mk    WWW archive of articles from the LP Newsletter.
;;; 28-OCT-94 mk    WWW page for ILOG.
;;; 10-NOV-94 mk    Updated ESL Prolog-2 entry.
;;;
;;; 1.25:
;;;  7-DEC-94 mk    Updated LIFE entry in part 2.
;;;
;;; 1.26:
;;; 16-JAN-95 mk    Added [1-18] History of Prolog.
;;; 16-JAN-95 mk    Updated IF/Prolog entry in part 2.
;;; 17-JAN-95 mk    Updated PNLA ftp address.
;;; 26-JAN-95 mk    Added DFKI Oz to [2-5].
;;;
;;; 1.27:
;;; 20-FEB-95 mk    Added LogTalk entry to [1-6].

*** Topics Covered:

There are currently two parts to the PRG:

   1. Introductory Matter and General Questions
   2. Prolog Implementations

Table of Contents (Part 1):

  [1-0]  Introduction
  [1-1]  Sources of information about Prolog
  [1-2]  Prolog-related Mailing Lists
  [1-3]  Books and Magazine Articles
  [1-4]  Prolog and Logic Programming Associations and Journals
  [1-5]  FTP Archives and Other Resources
  [1-6]  Free Object-Oriented Systems for Prolog
  [1-7]  Commercial Object-Oriented Systems for Prolog
  [1-8]  The Prolog 1000 Database
  [1-9]  X-Windows Interfaces
  [1-10] Is there a straight-forward way of compiling Prolog to C?
  [1-11] WAM emulators and tracers
  [1-12] What is the Basic Andorra Model and AKL?
  [1-13] What is Constraint Logic Programming?
  [1-14] How do you write portable programs in Prolog?
  [1-15] World-Wide Web (WWW) Resources
  [1-16] Prolog Job Postings
  [1-17] Is Prolog really used in Windows NT?
  [1-18] History of Prolog
  [1-A]  Acknowledgements

Prolog Implementations (Part 2):

  [2-0]  General information about Prolog Implementations
  [2-1]  Free Prolog Implementations
  [2-2]  Commercial Prolog Implementations
  [2-3]  Free Parallel Prolog Implementations
  [2-4]  Commercial Parallel Prolog Implementations
  [2-5]  Free Constraint Systems
  [2-6]  Commercial Constraint Systems
  [2-7]  Free Logic Programming Systems
  [2-8]  Commercial Logic Programming Systems
  [2-9]  Other Commercial Prolog Products
  [2-10] Prolog extensions, meta-interpreters, and pre-processors

Search for [#] to get to topic number # quickly. In newsreaders which
support digests (such as rn), [CTRL]-G will page through the answers.

----------------------------------------------------------------
Subject: [1-0] Introduction

Certain questions and topics come up frequently in the various network
discussion groups devoted to and related to Prolog and logic programming.
This file/article is an attempt to gather these questions and their
answers into a convenient reference for Prolog programmers.  It (or a
reference to it) is posted periodically.  The hope is that this will
cut down on the user time and network bandwidth used to post, read and
respond to the same questions over and over, as well as providing
education by answering questions some readers may not even have
thought to ask.

This guide lists Prolog and logic programming resources: archives,
newsgroups, books, magazines, compilers, interpreters and anything
else you can think of which has to do with the proliferation of Prolog
and logic programming. Also included is a list of suppliers of
products and a list of publishers. Topics can also include
unification, backtracking search, and other aspects of logic
programming. As Prolog has a strong historical tradition in Europe,
we've tried to ensure that the information is relevant to all readers,
including European and North American.

This is not a Prolog tutorial, nor is it an exhaustive list of all Prolog
intricacies.  Prolog is a very powerful and expressive language, but with
that power comes many complexities.  This list attempts to address the
ones that average Prolog programmers are likely to encounter.  If you are
new to Prolog, read one of the introductions listed in the answer to
question [1-3].

Please do not post homework questions to the comp.lang.prolog
newsgroup. You won't learn anything if somebody else does the problem
for you, and won't get any credit for your answer if your instructor
reads the newsgroup.

Please also avoid starting the debate on which language is better;
Prolog or Lisp, Prolog or C, and so on. Such discussions are rarely
productive, and nobody will change their opinion as a result of the
debate. The usual conclusion of such debates is that the languages are
Turing equivalent, but some languages are better suited for particular
tasks. For Prolog, the consensus is that it is a good choice for
problems involving logic and problems whose solution can be
represented or characterized succinctly in logical form. Some folks
feel Prolog is the best language for natural language processing;
others disagree.

This guide is posted regularly to comp.lang.prolog and comp.object.logic.
It may also be obtained by anonymous ftp from
   ftp.cs.cmu.edu:/user/ai/pubs/faqs/prolog/  [128.2.206.173]
using username "anonymous" and password "name@host" (substitute your
email address) or via AFS in the Andrew File System directory
   /afs/cs.cmu.edu/project/ai-repository/ai/pubs/faqs/prolog/
as the files prg_1.faq and prg_2.faq.

You can also obtain a copy of the FAQ by sending a message to
[e-mail] with
   Send PRG
in the message body.

The FAQ postings are also archived in the periodic posting archive on
   rtfm.mit.edu:/pub/usenet/news.answers/prolog/ [18.181.0.24]
If you do not have anonymous ftp access, you can access the archive by
mail server as well.  Send an E-mail message to
[e-mail] with "help" and "index" in the body on
separate lines for more information.

An automatically generated HTML version of the PRG is accessible by
WWW as part of the AI-related FAQs Mosaic page. The URL for this
resource is
   http://www.cs.cmu.edu:8001/Web/Groups/AI/html/faqs/top.html
The direct URL for the PRG is
   http://www.cs.cmu.edu:8001/Web/Groups/AI/html/faqs/lang/prolog/prg/top.html

If you need to cite the FAQ for some reason, use the following format:
   Mark Kantrowitz, "Prolog Resource Guide", comp.lang.prolog, <month>, <year>,
   ftp.cs.cmu.edu:/user/ai/pubs/faqs/prolog/prg_?.faq, [e-mail].

Disclaimer:

   We have taken great care in making the information in this document as
   accurate as possible. However we are not responsible for any problems
   which might occur from using information supplied in this guide.

----------------------------------------------------------------
Subject:  [1-1]  Sources of Information about Prolog

The newsgroups comp.lang.prolog, comp.object.logic, and (to a lesser
extent) comp.ai are a source of information and discussion about Prolog.
See also sci.logic. The newsgroup comp.constraints is for information
about constraint processing languages and related topics.

A "Frequently Asked Questions" posting is posted to comp.lang.prolog
twice a month by Jamie Andrews <[e-mail]>. The Prolog FAQ and this
Prolog Resource Guide are intended to complement one another.

The draft ISO standard for Prolog is available by anonymous ftp from
   ai.uga.edu:/pub/prolog.standard/ [128.192.12.9]
An unofficial summary of the draft ISO Prolog standard is available
from the same location as isoprolog.tex or isoprolog.ps.Z.  Send mail
to Michael Covington <[e-mail]> for more information about
his summary of the standard. For more information about the ISO Prolog
standard itself, write to Roger Scowen, ISO/IEC JTC1 SC22 WG17 (Prolog)
convener, DITC/93, National Physical Laboratory, TEDDINGTON, Middlesex
TW11 0LW, UNITED KINGDOM, call [phone], fax [phone],
or send email to [e-mail].

Richard O'Keefe's 1984 Prolog standard draft is available by anonymous
FTP from
   ftp.ecrc.de:/pub/eclipse/std/plstd.doc

----------------------------------------------------------------
Subject: [1-2]  Mailing Lists

Prolog and Logic Programming:
   [e-mail] (general)
   [e-mail] (nitty gritty)

   All requests to be added to or deleted from this list, problems,
   questions, etc., should be sent to [e-mail]

   [The host sushi.stanford.edu no longer exists, as of 11/24/92.
    Does anybody know the new location of the mailing lists?]

Lambda Prolog:
   [e-mail]

   To subscribe, send mail to [e-mail].

Electronic Journal of Functional and Logic Programming (EJFLP)

   EJFLP is a refereed journal that will be distributed for free via e-mail.
   The aim of EJFLP is to create a new medium for research investigating the
   integration of the functional, logic and constraint programming paradigms.

   For instructions on submitting a paper, send an empty mail message with
      Subject: Help
   to:
      [e-mail].
   You will receive an acknowledgment of your submission within a few hours.

   To subscribe to the journal, send an empty mail message to the following
   address:
       [e-mail]
   You will receive an acknowledgment of your subscription within a few days.

   If there are any problems with the mail-server, send mail to
   [e-mail].

   The editorial board is: Rita Loogen (RWTH Aachen), Herbert Kuchen (RWTH
   Aachen), Michael Hanus (MPI-Saarbruecken), Manuel MT Chakravarty (TU
   Berlin), Martin Koehler (Imperial College London), Yike Guo (Imperial
   College London), Mario Rodriguez-Artalejo (Univ. Madrid), Andy Krall
   (TU Wien), Andy Mueck (LMU Muenchen), Tetsuo Ida (Univ. Tsukuba,
   Japan), Hendrik C.R. Lock (IBM Heidelberg), Andreas Hallmann (Univ.
   Dortmund), Peter Padawitz (Univ. Dortmund), Christoph Brzoska (Univ.
   Karlsruhe).

PDC-L:
   [e-mail] is a discussion list for PDC Prolog users.

   To subscribe, send mail to [e-mail] with
       SUBSCRIBE PDC-L <your full name>
   in the message body.

Theorem Provers:
   [e-mail]

   This (unmoderated) list is intended for announcements of interest to
   people interested in automated theorem proving.

   To subscribe, send your email address to [e-mail].

Type Theory:
   [e-mail]

   Moderated mailing list about type theory. Archived on
      theory.lcs.mit.edu:/pub/meyer/

   To subscribe, send mail to [e-mail].

Logic:
   [e-mail]

   Moderated mailing list about logic. Archived on
      theory.lcs.mit.edu:/pub/meyer/

   To subscribe, send mail to [e-mail]

ALP (French Chapter):
   [e-mail]

   La liste de diffusion "prog-logique" est le support electronique de
   communication de la section francaise de l'ALP (Association for Logic
   Programming), groupe de travail AFCET. Elle complete la lettre du
   groupe publiee trimestriellement.

   Pour vous abonner ou vous desabonner, il faut envoyer un "mail" au
   serveur de listes, a l'adresse
      [e-mail]
   sans sujet ni signature, et dont le corps du message contient
        SUB prog-logique Prenom Nom
   Un acquittement est renvoye par messagerie. Pour desabonnement, ecrit
        SIGNOFF prog-logique
   Les requetes envoyees directement a la liste ne seront pas prises en
   compte.

----------------------------------------------------------------
Subject: [1-3] Books and Magazine Articles

A BiBTeX bibliography of Logic Programming Conferences is available by
anonymous ftp from duck.dfki.uni-sb.de. See [1-5] below.

A partially annotated bibliography of work on integrating
object-oriented and logic programming is available by anonymous ftp
from menaik.cs.ualberta.ca:/pub/oolog/ in PostScript and BibTeX
formats. Written by Vladimir Alexiev <[e-mail]>.

The following books are regarded as popular and widely used. Also
included are some books about WAM. This is not intended to be a complete
Prolog bibliography.

Prolog Programming:

   Covington, Michael A.; Nute, D.; and Vellino, A. "Prolog
   Programming in Depth", Scott, Foresman & Co., 1987. ISBN 0-521-40984-5
   (Out of print, but new edition coming soon. Copies of the 1987
   edition are still available from the University of Georgia
   Bookstore, at 706-542-7131.)

   Clocksin, W.F. and Mellish, C.S: "Programming in Prolog", 3rd Ed.
   Springer Verlag, 1987. 281 pages, ISBN 0-387-17539-3 ($29).
   [Basic introduction to Prolog.]

   Coelho, H., and Cotta, J.C., "Prolog by Example", Springer Verlag,
   1988. 381 pages, ISBN 0-387-18313-2 ($39.50).

   Cooke, Daniel E., "Logic: The Basis for Understanding Prolog",
   Ablex, Norwood, NJ, 1994. 224 pages, ISBN 1-56750-028-5 ($27.50).
   [Intro to Prolog with a review of the basic ideas underlying the language.]

   Conlon, Tom: "Programming in Parlog". Addison-Wesley, 1989,
   ISBN 0-201-17450-2.

   Dawe, C.M. and M.S. Dawe, "Prolog for Computer Science", Springer
   Verlag, 1994. 190 pages, ISBN 0-387-19811-3 paper ($35). [Intro to
   computer science using Prolog.]

   Dodd, Anthony, "Prolog: A logical approach", Oxford University
   Press, New York, 1990, 556 pages. ISBN 0-198-53822-7 (cloth), $52.50;
   ISBN 0-198-53821-9 (paperback), $26.00.

   Kluzniak and Szpakowicz: "Prolog for Programmers", Academic Press 1985

   G. L. Lazarev, "Why Prolog? Justifying Logic Programming for Practical
   Applications", Prentice Hall, 1989. [Software engineering bent.
   Emphasizes advantages of declarative programming.]

   Le, Tu Van,  "Techniques of Prolog programming, with implementation
   of logical negation and quantified goals", John Wiley, New York, 1993.
   ISBN: 0-471-57175-X (American edition), 0-471-59970-O (International
   edition).  LnProlog, a Prolog interpreter that supports negative
   finding queries and quantified queries is available together with
   the book.

   Saint-Dizier, P., "An Introduction to Programming in Prolog",
   Springer Verlag, 1990. 184 pages, ISBN 0-387-97144-0 paper ($25).
   [Tutorial introduction, with simple examples of AI programs and games.]

   Leon Sterling, editor, "The Practice of Prolog", MIT Press, 1990.
   342 pages, ISBN 0-262-19301-9, $39.95.

Advanced Prolog Programming:

   O'Keefe, Richard A., "The Craft of PROLOG", MIT Press, 1990, 410 pages.
   ISBN 0-262-15039-5, $42.50.

   Peter Ross, "Advanced Prolog: Techniques and Examples",
   Addison-Wesley, 1989, ISBN 0-201-17527-4.

   Leon Sterling and Ehud Shapiro, "The Art of Prolog: Advanced
   Programming Techniques", 2nd Edition, MIT Press, 1994. 688 pages,
   ISBN 0-262-19338-8 ($49.95).
   [Source code for the book is available in ftp.cwru.edu:/ArtOfProlog/.
    There is a subdirectory for each chapter of the book containing the
    text of the programs in that chapter.]

AI and Prolog:

   Yoav Shoham, "Artificial Intelligence Techniques in Prolog", Morgan
   Kaufmann Publishers, 1993, 400 pages. ISBN 1-55860-167-8 (paper) $39.95.
   ISBN 1-55860-319-0 (cloth) $49.95. [Topics include search, backward
   chaining, data-driven methods, truth maintenance, constraint
   satisfaction, reasoning with uncertainty, planning, temporal
   reasoning, machine learning, and natural language processing. Prolog
   source for all the programs in the book is available by anonymous ftp
   from unix.sri.com:/pub/shoham/]

   Bratko, Ivan, "Programming in Prolog for Artificial Intelligence",
   2nd Edition, Addison-Wesley, 1990. [Good introduction to Prolog and AI.
   A bit large, though, for an Intro to Prolog course. Includes
   discussion of the 8-queens problem.]

   Dennis Merritt, "Building Expert Systems in Prolog", Springer-Verlag, 1989.
   358 pages, ISBN 0-387-97016-9 hardcover ($52).
   Explains how to build various expert system shells in Prolog, including
   forward/backward chaining, FOOPS, rete-network, frames, solving
   Rubik's cube and more. Includes complete source code listings.
   (Source code from the book is also sold on disk by Amzi! Inc. and
   is available by anonymous FTP from
      ftp.std.com:/ftp/vendors/amzi/programs/
      ftp.cs.cmu.edu:/user/ai/areas/expert/systems/amzi/programs/
   as the files xsip.*)

   Dennis Merritt: "Adventure in Prolog", Springer-Verlag, 1990.
   186 papers, ISBN 0-387-97315-X hardcover ($38).
   Teaches Prolog by leading the reader through the construction of an
   adventure game. The exercises lead the reader through three other
   programs:  an intelligent database, an expert system and an order-entry
   program.  While most texts teach Prolog with fragments of interesting code,
   this book takes a more pragmatic (as opposed to theoretical approach) and
   shows the reader how to assemble complete Prolog programs.

   Gazdar, G. and Mellish, C., "Natural Language Processing in Prolog:
   An Introduction to Computational Linguistics", Addison-Wesley,
   Reading, Massachusetts, 1989. (There are three different editions
   of the book, one for Lisp, one for Prolog, and one for Pop-11.)

   Fernando C.N. Pereira and Stuart M. Shieber, "Prolog and
   Natural-Language Analysis", CSLI Lecture Notes Number 10, Stanford,
   CA, 1987. 286 pages, ISBN 0-937073-18-0.

   Michael A. Covington, "Natural Language Processing for Prolog
   Programmers", Prentice-Hall, Englewood Cliffs, NJ, 1994. ISBN
   0-13-629213-5.

   Harvey Abramson and Veronica Dahl, "Logic Grammars", Springer-Verlag,
   New York, 1989, 234 pages, ISBN 0-387-96961-6.

   Peter Flach, "Simply Logical: Intelligent Reasoning by Example",
   John Wiley & Sons, 1994, 256 pages. ISBN 0-471-94152-2 paper ($31.95).
   [Covers theoretical and practical aspects of Prolog programming as well
   as AI topics like knowledge representation, search, heuristics,
   abduction, default reasoning, and induction. Every technique is
   accompanied by a Prolog program that implements it. More information
   about the book is available from
      http://machtig.kub.nl:2080/Infolab/Peter/SimplyLogical.html
   or by email from [e-mail].]

Prolog and Object-Oriented Programming:

   Chris Moss, "Prolog++ The Power of Object-Oriented and Logic
   Programming", Addison-Wesley, 1994. 312 pages, ISBN 0-201-56507-2. UK
   price is 21.95 pounds. [This paperback includes a special offer to
   obtain a Prolog++ compiler from LPA for Windows 3.1 or Macintosh. UK
   price is 29.95 pounds (plus 17.5 percent VAT) plus 5.00 pounds postage
   and handling. Elsewhere the cost is $49.95 plus $8 p&h.]

Logic Programming:

   Hogger, Christopher J., "Introduction to Logic Programming",
   Academic Press, 1984. 278 pages. ISBN 0-12-352090-8 (alk. paper)
   ISBN 0-12-352092-4 (pbk.).

   Hogger, Christopher J., "Essentials of Logic Programming",
   Clarendon Press, Oxford, 1990. ISBN 0-19-853820-0. [Covers both
   foundations and more practical material, relating it all to Prolog.
   Takes a different approach than his first intro, dividing the book
   into many short "themes" instead of chapters, and including many
   excercises (with some answers).]

   Kowalski, R.A.: "Logic for Problem Solving", New York 1979, Elsevier Publ.

   LLoyd, John: "Foundations of Logic Programming", 2nd Edition,
   Springer-Verlag, 1988. (Intro to logic programming theory.)

   David Maier and David S. Warren: "Computing with Logic: Logic
   Programming with Prolog", Benjamin Cummings, Menlo Park, CA, 1989.

   Nilsson, Ulf and Maluszynski, Jan, "Logic, Programming and Prolog",
   John Wiley & Sons, 1990, ISBN 0-471-92625-6.

   Subrata Kumar DAS, "Deductive Databases and Logic Programming",
   Addison-Wesley Publishing Company, July 1992, 448 pages.
   ISBN 0-201-56897-7.

Constraint Logic Programming and Constraint Satisfaction:

   Bennaceur, Hachemi and Gerard Plateau, "An exact algorithm for the
   constraint satisfaction problem: Application to logical inference",
   Information Processing Letters 48(3):151-158, November 19, 1993.

   Cohen, J., "Constraint Logic Programming Languages", Communciations
   of the ACM 33(7):52-68, 1992. [Good introduction to CLP and
   includes a historical overview.]

   Freeman-Benson, B.N., Maloney, J., and Borning, A., "An Incremental
   Constraint Solver", Communications of the ACM 33(1):54-63, 1990.
   [Includes a good reading list on the history and applications of
   constraints.]

   Freuder, Eugene C., and Richard J. Wallace, "Partial constraint
   satisfaction", Artificial Intelligence 58(1-3):21-70, December 1992.

   Van Hentenryck, Pascal, "Constraint Satisfaction in Logic Programming",
   MIT Press, Cambridge, MA, 1989, ISBN 0-262-08181-4.

   Jaffar, Joxan and Jean-Louis Lassez, "Constraint Logic Programming", in
   Proceedings of the 14th ACM Symposium on Principles of Programming
   Languages (POPL), Munich, Germany, pages 111-119, 1987.
   [A longer version appears in Joxan Jaffar and Jean-Louis Lassez,
   "Constraint Logic Programming", Technical Report 86-74, Monash
   University, Victoria, Australia, June 1986.]

   Kumar, Vipin, "Algorithms for Constraint-Satisfaction Problems: A
   Survey", AI Magazine 13(1):32-44, 1992.

   Mackworth, Alan K., "The logic of constraint satisfaction", Artificial
   Intelligence 58:3-20, 1992.

   Meseguer, P., "Constraint Satisfaction Problems: An Overview", AICOM
   2(1):3-17, 1989.

   Steele, Guy L., "The Definition and Implementation of A Computer
   Programming Language Based on Constraints", PhD thesis, MIT, 1980.

   Tsang, Edward, "Foundations of Constraint Satisfaction", Academic
   Press, 1993. 421 pages, ISBN 0-12-701610-4 ($75). [Good overview.]

   Zhang, Ying and Alan K. Mackworth, "Constraint Programming in
   Constraint Nets", in Position Papers for the First Workshop on
   Principles and Practice of Constraint Programming, pages 303-312,
   Newport, RI, April 28-30, 1993.

   [See also the articles on Constraint Networks (pages 276-285) and
   Constraint Satisfaction (pages 285-293) in Shapiro's Encyclopedia
   of Artificial Intelligence.]

Prolog Implementations and WAMs:

   Ait-Kaci, Hassan, "Warren's Abstract Machine: A Tutorial Reconstruction",
   MIT Press, Cambridge, MA. 1991.
   125 pages, ISBN 0-262-51058-8 paper ($17.50), 0-262-01123-9 cloth.

   Patrice Boizumault, "The Implementation of Prolog", Princeton
   University Press, Princeton, NJ, 1993.  Translated by Ara M.
   Djamboulian and Jamal Fattouh. ISBN 0-691-08757-1, 357 pages ($49.50).
   [The interpreters developed in the book are available by anonymous
   ftp from cnam.cnam.fr:/pub/Boizumault/. See [2-1].]

   Campbell, J.A. (ed):  "Implementations of Prolog", John Wiley, 1984

   Peter M. Kogge, "The Architecture of Symbolic Computers",
   McGraw-Hill, 1991. ISBN 0-07-035596-7.
      Includes sections on memory management, the SECD and
      Warren Abstract Machines, and overviews of the various
      Lisp Machine architectures.

   David H. D. Warren: "An Abstract Prolog Instruction Set", Technical Note
   No 309, SRI International, Menlo Park, CA, 1983.

   David H. D. Warren, "Logic Programming and Compiler Writing," in
   Software-Practice and Experience 10(2):97-125, 1980.

   J. Cohen and T. Hickey, "Parsing and Compiling using Prolog",
   ACM Transactions on Programming Languages and Systems (TOPLAS),
   9(2):125-163, 1987.

   J. Paakki, "Prolog in practical compiler writing", The Computer
   Journal 34(1):64-72, 1991. (But see Letters to the Editor, The
   Computer Journal 35(3):313, 1992.)

   Jonathan P. Bowen, "From Programs to Object Code using Logic and Logic
   Programming", in R. Giegerich and S. L. Graham, editors, Code
   Generation -- Concepts, Tools, Techniques, pages 173-192,
   Springer-Verlag, 1992.

   Jonathan P. Bowen, "From Programs to Object Code and back again using
   Logic Programming: Compilation and Decompilation", Journal of
   Software Maintenance: Research and Practice 5(4):205-234, December 1993.

Parallel Prologs:

   Gregory, Steve: "Parallel Logic Programming in Parlog: The Language
   and Its Implementation", Addison-Wesley, 1987, ISBN 0-201-19241-1.

   Tick, E.: "Parallel Logic Programming". MIT Press, 1991

Miscellaneous:

   Deville, Yves: "Logic Programming, Systematic Program Development",
   International Series in Logic Programming, Addison-Wesley, 1990, 338 pages.
   ISBN 0-201-17576-2.

   Wolfram, D.A., "The Clausal Theory of Types", Cambridge Tracts in
   Theoretical Computer Science {\bf 21}, Cambridge University Press,
   1993.

Magazine Articles:

   PCAI Magzine, September/October 1993. Article on exploring Prolog,
   showing the first steps to four applications -- an adventure game, an
   object-oriented shell, a tax program, and an animal guessing game.
   An excerpt of this article is available from
      ftp.cs.cmu.edu:/user/ai/lang/prolog/doc/intro/explore.doc

   BYTE Magazine, August 1987. 5 introductory articles on Prolog.
   Applications include logic grammars and simulating a microprocessor.

   Uwe Schreiweis: Beredte Logik, Konzepte der 'KI-Sprache" Prolog,
   (Eloquent Logic, Concepts of the AI language Prolog), iX Magazine,
   October 1992, pages 84-90.

   Uwe Schreiweis: Basis der Fuenf, Die Sprache Prolog in der Public
   Domain, (Base of the Five, Prolog in the Public Domain), iX Magazine,
   October 1992, pages 92-94.

   Uwe Schreiweis: Fuenfte Generation, Kommerzielle Prolog-Systeme,
   (Fifth Generation, Commercial Prolog Systems), iX Magazine, October
   1992, pages 96-102.

   Klaus Bothe: Weniger Raum, Speicherplatzbezogener Prolog-Benchmark,
   (Less Space, A Space Oriented Prolog Benchmark), iX Magazine, October
   1992, pages 106-7.

Magazines Related to Prolog:

   Logic Programming Newsletter (4 issues/yr)
   Included with membership in the Association for Logic Programming
   ($20 regular, $10 students). For membership information, write to
   Cheryl Anderson (ALP), DoC-ICSTM, 180 Queens Gate, London SW7 2BZ,
   UK, phone [phone] x5011, fax [phone], or send email
   to [e-mail]. Contributions are welcome and should be sent
   to Andrew Davidson <[e-mail]>. Selected articles from the
   newsletter are available from the WWW archive
      http://www.cs.mu.oz.au/~ad/alp/archive.html

   AI Communications (4 issues/yr)
   "The European Journal on Artificial Intelligence"  ISSN 0921-7126,
   European Coordinating Committee for Artificial Intelligence.

   AI Expert (issued monthly) ISSN 0888-3785, Miller Freeman Publishers
   See a copy of the magazine for list of BBS's in NA. On CompuServe: GO
   AIEXPERT. Regularly reviews Prolog interpreters and compilers.

   Expert Systems (issued Feb, May, Aug and Nov) ISSN 0266-4720,
   Learned Information (Europe) Ltd. Subscription: GBP 85 or USD 110

   IEEE Expert (issued bimonthly) ISSN 0885-9000, IEEE Computer Society

   The Journal of Logic Programming (issued bimonthly), (North-Holland),
   Elsevier Publishing Company, ISSN 0743-1066

   New Generation Computing, Springer-Verlag. (LOTS of Prolog in it.)

----------------------------------------------------------------
Subject: [1-4] Prolog and Logic Programming Associations and Journals

ASSOCIATION FOR LOGIC PROGRAMMING (ALP)
Members receive the ALP Newsletter.

For information on membership, contact

   Cheryl Anderson
   ALP Administrative Secretary
   Department of Computing
   Imperial College
   180 Queen's Gate
   London, SW7 2BZ, UK

   Email:   [e-mail]
   Fax:    [phone]
   Phone:  [phone] x5011

Newsletter submissions should be sent to

   Andrew Davison
   Department of Computer Science
   University of Melbourne
   Parkville
   Melbourne, Victoria 3052
   AUSTRALIA

   Email:   [e-mail]
   Fax:    [phone]
   Phone:  [phone] / 5230
   Telex:   AA 35185

----------------------------------------------------------------
Subject: [1-5] FTP Archives and Other Resources

The following are achives that contain Prolog-related material, such as
code, interpreters, articles, etc. Most of the archives are ftp sites.
They are listed by domain.name and [IP Address]. To access them and
download programs type at the prompt:

        ftp <site name> (or IP address)
        login: "anonymous",
        password: your own return email address,
        cd <directory>, ls to see files,
        set binary,
        get <filename> to transfer file to your system
        stop with quit or exit

Deviations from this general scheme may occur but the above should
work in most cases.

CMU AI Repository, Prolog Section:

   The Prolog Section of the CMU Artificial Intelligence Repository
   (aka "The Prolog Repository") is accessible by anonymous ftp to
      ftp.cs.cmu.edu:/user/ai/lang/prolog/ [128.2.206.173]
   through the AFS directory
      /afs/cs.cmu.edu/project/ai-repository/ai/lang/prolog/
   or by WWW from the URL
      http://www.cs.cmu.edu:8001/Web/Groups/AI/html/repository.html
   and includes more than 110 megabytes of sources and other materials
   of interest to Prolog programmers, including all freely
   distributable implementations and many programs. The contents of the
   CMU AI Repository has been keyword indexed to provide convenient
   browsing of the contents.

   The repository has standardized on using 'tar' for producing
   archives of files and 'gzip' for compression.

   To search the keyword index by mail, send a message to:
      [e-mail]
   with one or more lines containing calls to the keys command, such as:
      keys prolog gui
   in the message body.  Keywords may be regular expressions and are
   compared with the index in a case-insensitive conjunctive fashion.
   You'll get a response by return mail. Do not include anything else in
   the Subject line of the message or in the message body.  For help on
   the query mail server, include:
      help
   instead.

   A Mosaic interface to the keyword searching program is in the
   works.  We also plan to make the source code (including indexes) to
   this program available, as soon as it is stable.

   Most of the Prolog Section of the AI Repository appears on Prime Time
   Freeware for AI, Issue 1-1, a mixed-media book/CD-ROM publication. It
   includes two ISO-9660 CD-ROMs bound into a 224 page book and sells
   (list) for US$60 plus applicable sales tax and shipping and handling
   charges. Payable through Visa, Mastercard, postal money orders in US
   funds, and checks in US funds drawn on a US bank. For more
   information write to Prime Time Freeware, 370 Altair Way, Suite 150,
   Sunnyvale, CA  94086  USA, call 408-433-9662, 408-433-0727 (fax),
   or send email to [e-mail].

   Contributions of software and other materials are always welcome but
   must be accompanied by an unambiguous copyright statement that grants
   permission for free use, copying, and distribution -- either a
   declaration by the author that the materials are in the public domain,
   that the materials are subject to the GNU General Public License (cite
   version), or that the materials are subject to copyright, but the
   copyright holder grants permission for free use, copying, and
   distribution. (We will tell you if the copying permissions are too
   restrictive for us to include the materials in the repository.)
   Inclusion of materials in the repository does not modify their
   copyright status in any way. Materials may be placed in:
      ftp.cs.cmu.edu:/user/ai/new/
   When you put anything in this directory, please send mail to
      [e-mail]
   giving us permission to distribute the files, and state whether
   this permission is just for the AI Repository, or also includes
   publication on the CD-ROM version (Prime Time Freeware for AI).
   We would also appreciate if you would include a 0.doc file for your
   package; see /user/ai/new/package.doc for a template. (If you don't
   have the time to write your own, we can write it for you based on
   the information in your package.)

   The Prolog Section of the AI Repository is maintained by Mark Kantrowitz
   <[e-mail]>.

Artificial Intelligence Programs:
   ai.uga.edu:/pub/ [128.192.12.9]

   The University of Georgia AI FTP Library contains public domain
   Prologs, such as Open Prolog and ESL PD Prolog, PrEd (a small text
   editor for Prolog), and some miscellaneous prolog programs in
      ai.uga.edu:/pub/prolog/
   A copy of the programs from the book by Covington, Nute, and Vellino, (see
   the section on Books below), is in
      ai.uga.edu:/pub/prolog.book/
   and the draft ISO standard for prolog is in
      ai.uga.edu:/pub/prolog.standard/
   Some technical reports with accompanying code are in
      ai.uga.edu:/pub/ai.reports/
   Other materials of interest are in
      ai.uga.edu:/pub/natural.language/
      ai.uga.edu:/pub/natural.language.book/
   Maintained by Michael Covington <[e-mail]>.

ALE:
   ALE (Attribute Logic Engine), a freeware system written in
   Prolog, integrates phrase structure parsing and constraint logic
   programming with typed feature structures as terms.  Types are
   arranged in an inheritance hierarchy and specified for the features
   and value types for which they are appropriate.  Grammars may also
   interleave unification steps with logic program goal calls (as can be
   done in DCGs), thus allowing parsing to be interleaved with other
   system components.  While ALE was developed to handle HPSG grammars,
   it can also execute PATR-II grammars, DCG grammars, Prolog, Prolog-II,
   and LOGIN programs, etc. Grammars and programs are specified with a
   version of Rounds-Kasper Attribute Value Logic with macros and
   variables.  ALE supports lexical rules and empty categories for
   grammars, using a bottom-up, all-paths dynamic chart parser. ALE
   supports last call optimization, negation by failure and cuts in
   definite clauses, which may be used independently or integrated into
   grammars. The system is distributed with several sample grammars,
   including a fairly comprehensive implementation of a head-driven
   phrase structure grammar for English. Version 2.0 of ALE is
   available free for research purposes by anonymous ftp from
      j.gp.cs.cmu.edu:/usr1/carp/ftp/
   as the files ale.*, or from the CMU AI Repository in
      ftp.cs.cmu.edu:/user/ai/lang/prolog/code/parsing/ale/
   For more information write to Bob Carpenter <[e-mail]> or
   Gerald Penn <[e-mail]>.

ALP-UK Library:
   The best Prolog library currently is the one collected by the ALP-UK
   group. It is available to members at 30 pounds sterling for a Sun
   cartridge or 2 pounds/IBM DOS disk. (non-members maybe, how much?) It
   contains MBs of Prolog systems (including SB Prolog), libraries
   (including the Edinburgh library), benchmarks, grammars, theorem provers,
   object and graphics systems etc. For more information, write to ALP-UK
   Library, Sanjay Raina, Librarian, Dept. of Computer Science, University
   of Bristol, University Walk, Bristol BS8 1TR, UK, call [phone]
   x3304, or send email to [e-mail].

CASLOG
   CASLOG (Complexity Analysis System for LOGic) is an experimental
   semi-automatic complexity analysis system for logic programs. It can
   perform the worst-case analysis for complexity measures: argument size
   complexity, number of solutions complexity, and time complexity.

   CASLOG extends the techniques developed for analyzing imperative and
   functional languages to deal with nondeterminism and generation of
   multiple solutions via backtracking in logic languages. The analyses
   for different complexity measures are implemented in a unified
   framework and share several common features. First, the predicates in
   a program are processed in an order generated by a bottom-up
   topological sorting over the call graph of the program. Second, the
   complexity function for a predicate is derived from the complexity
   function of its clauses by using the information about the mutual
   exclusion relationships between its clauses. Third, the complexity
   function for a clause is inferred based on the data dependency
   relationships between its literals. Fourth, the complexity functions
   for recursive clauses are in the form of difference equations and are
   transformed into closed form functions using difference equation
   solving techniques. This unified framework can simplify proofs of
   correctness and the implementation of the algorithms.

   CASLOG is available by anonymous ftp from cs.arizona.edu:/caslog/. This
   is an alpha distribution, and includes CASLOG version 1.0, a
   preliminary user manual, a paper on CASLOG, and a set of examples.
   For more information, contact Nai-Wei Lin <[e-mail]>.

Constraint Programming Paper Archive:
   Aarhus University, Denmark, has established an anonymous ftp archive
   for papers on "Constraint Programming" at ftp.daimi.aau.dk:/pub/CLP/.
   For further information, contact Brian H. Mayoh <[e-mail]>.

CSP:

   Some constraint-related papers by a research group at the
   University of Washington are available by anonymous ftp from
      june.cs.washington.edu:/pub/constraints/papers/
   The papers from the 1994 Principles and Practice of Constraint
   Programming Workshop are available in
      june.cs.washington.edu:/pub/constraints/papers/ppcp94/
   There are also implementations of several constraint satisfaction
   algorithms and constraint-based systems, including the DeltaBlue and
   SkyBlue algorithms, the Multi-Garnet user interface toolkit, ThingLab
   II, and CoolDraw (a constraint-based drawing system), in
   subdirectories of
      june.cs.washington.edu:/pub/constraints/code/
   The ftp archive is also accessible via WWW:
      http://web.cs.city.ac.uk/archive/constraints/constraints.html
   All the source code is in the public domain. For more information,
   write to Alan Borning <[e-mail]>.

   C implementations of a number of constraint satisfaction algorithms
   are available by anonymous ftp from
      ftp.cs.ualberta.ca:/pub/ai/csp/
   Get the files README and csplib.tar.Z.  The algorithms include
   variations on backtracking (backjumping, backmarking, chronological
   backtracking, etc.), local consistency preprocessing algorithms (e.g.,
   arc consistency), and random problem generators. For more information,
   write to Peter van Beek <[e-mail]>.

Eden:
   Eden is a Poplog-based AI microworld developed by Simon Perkins,
   Jocelyn Paine and Edmund Chattoe of the Oxford University Artificial
   Intelligence Society. It is intended to serve as a testbed for
   learning and planning programs. Programs written in Pop-11, Prolog,
   Lisp, and ML control a "bug" that lives in a 2-dimensional world. Any
   kind of algorithm may be used to control the bug, including genetic
   algorithms, neural nets, and rule-based systems. Eden consists of a
   grid of cells, each of which can contain objects such as keys, doors,
   boulders and quicksand. Bug's objective is to find and eat a piece of
   food which the simulator has placed somewhere within this grid. To do
   this, Bug must negotiate its way towards the food while dealing
   intelligently with obstacles. Eden's laws of physics allow Bug to take
   one of several different actions when it encounters an object. The
   simulator then works out the consequences of the chosen action on Bug
   and on Eden, and displays these graphically in a Ved window. Bug's
   perceptions are updated to reflect the new state of the world, and the
   cycle repeats. Eden is available by anonymous ftp from the Imperial
   College archive in
      src.doc.ic.ac.uk:/packages/prolog-pd-software/ [146.169.2.10]
   as the file eden.tar.Z. (Note: This is really a link to the
   directory computing/programming/languages/prolog/pd-software/.)
   Eden includes PopBeast, a simple Prolog bug which can read and
   parse simple commands, extract their meaning, plan how to satisfy
   these commands, and then carry out the plans.

   Parts of the current Eden are coded in Pop-11, so porting it to
   Prologs other than Poplog will require some effort. Most of the
   recoding needed is in the grid-world simulator and the definition of
   objects. Send mail to Jocelyn Paine <[e-mail]> if
   you're willing to try this.

FW_Rules:

   FW_RULES is a Sicstus Prolog library providing a compiler for forward
   chaining rules.  The implementation is based on a non-state saving
   technique coupled with an indexing mechanism on the working memory
   based on C bitwise operations to achieve efficiency. The library
   supports interoperability between the forward chaining language and
   the underlying Prolog engine.  Terms in the working memory are
   represented as Prolog facts and can be accessed from Prolog to perform
   deduction. It is available by anonymous FTP from
      ftp.cs.unibo.it:/pub/gaspari/fw_rules/
   as the files README and fw_rules.tar.Z. For more information,
   please write to Mauro Gaspari <[e-mail]>.

HDRUG:

   Hdrug is an environment to develop logic grammars, parsers, and
   generators for natural languages.  The package comes with a number of
   example grammars, including a Categorial Grammar, a Tree Adjoining
   Grammar, a Unification Grammar in the spirit of Head-driven Phrase
   Structure Grammar, an Extraposition Grammar, a Definite Clause
   Grammar, and a port of the HPSG grammar from Bob Carpenter's ALE
   system. Each of the grammars comes with a set of parsers, such as
   Earley-like chart parsers, left-corner parsers and head-driven
   parsers. Some grammars come with variants of the head-driven
   generator. The package allows easy comparison of different
   parsers/generators, extensive possibilities of compiling feature
   equations into Prolog terms, graphical (Tk), LaTeX and ordinary Prolog
   output of trees, feature structures and Prolog terms, and plotted
   graphs and tables of statistical information. Hdrug runs in Sicstus
   Prolog and requires ProTcl and Tcl/Tk. It is available by anonymous
   FTP from
      tyr.let.rug.nl:/pub/prolog-app/Hdrug/
   or by WWW from
      http://tyr.let.rug.nl/~vannoord/prolog-app/Hdrug/
   For more information, write to Gertjan van Noord <[e-mail]>.

Logic Programming Bibliographies:
   duck.dfki.uni-sb.de:/pub/lp-proceedings/ [134.96.188.92]

   The ftp server supports tar'ing on the fly, so if you type "get
   bibtex.tar" you will get a tar'ed version of the "bibtex" directory.

   BibTeX entries for the proceedings of the following conferences
   are included: SLP84-87,91, NACLP89-90, ILPS91, ICLP82,84,86-91,93,
      JICLP92, LP88, RTA89,93, PLILP90-92, ALPUK91, ICOT92, ALP90,92,
      CADE90,92, CTRS90,92, LICS86-91, UNIF89, EPIA89,91,93, TACS91,
      TAPSOFT93, EAIA90, FGCS92, FAC, ILPS93, PEPM91,93
   and the following journals: JLP85-93, JAR91-93, JSC91-93, IANDC82-92.

   The bibliography is mirrored by the Universidade Nova de Lisboa.
   In addition, the bibliography can be searched using either WAIS or
   GOPHER. To search the lp-proceedings using WAIS, use the
      lp-proceedings.src
   wais source, available from the directory of servers. To search the
   lp-proceedings using GOPHER, point the client to gopher.fct.unl.pt,
   and follow the directories
      "Research/Bibliography/Logic Programming Proceedings".
   Searching should be easier than retrieving the entire package every
   time you want to locate a particular article.

   Send comments and bug reports to [e-mail].

Machine Learning Algorithms Implemented in Prolog:

   In 1988 the Special Interest Group on Machine Learning of the German
   Society for Computer Science (GI e.V.) decided to establish a library
   of PROLOG implementations of Machine Learning algorithms. The library
   includes - amongst others - PROLOG implementations of Winston's arch,
   Becker's AQ-PROLOG, Fisher's COBWEB, Brazdil's generation of
   discriminations from derivation trees, Quinlan's ID3, FOIL, IDT,
   substitution matching, explanation based generalization, inverse
   resolution, and Mitchell's version spaces algorithm.
   All algorithms are written in Edinburgh Prolog syntax. Most of the
   algorithms are copyleft under the GNU General Public License.
   The programs are currently available via anonymous ftp-server from
   the GMD:

        ftp.gmd.de:/gmd/mlt/ML-Program-Library/ [129.26.8.84]

   They are also available by surface mail from Thomas Hoppe,
   Projektgruppe KIT, Technische Universitaet Berlin, Franklinstr. 28/29,
   10629 Berlin, Germany. Files will be distributed via MS-DOS formated
   3.5 inch floppy (double, high and extra-high density),  which should
   be included with your request. You can also get them by sending an email
   message to Thomas Hoppe (see below).

   Send additional PROLOG implementations of Machine Learning
   Algorithms, complaints about them and detected bugs or problems
   to Thomas Hoppe, <[e-mail]>. Send suggestions and
   complaints about the ftp library to Werner Emde, Gesellschaft
   fuer Mathematik und Datenverarbeitung, Bonn, <[e-mail]>.


Natural Language Processing in Prolog:

   The Prolog and DCG programs from Pereira and Shieber's book, "Prolog
   and Natural Language Analysis", are available by anonymous ftp from
   ftp.das.harvard.edu:/pub/shieber/pnla/. See the file README for the
   conditions under which the material is distributed. If you retrieve
   the files, please send an email message to the authors letting them
   know how you plan to use them. For further information, write to
   Fernando Pereira <[e-mail]> or Stuart Shieber
   <[e-mail]>.

Parser:
   A parser for standard Prolog text written in C is available by
   anonymous ftp from
      trappist.elis.rug.ac.be:/pub/prolog/
   It consists of only three modules (tokenizer, parser, and display
   routine) and an interface module to integrate it with an existing
   Prolog system. It is completely deterministic and about 10 times
   faster than O'Keefe's public domain parser written in Prolog.
   For more information, write to Koen De Bosschere <[e-mail]>.

Partial Evaluation:

   Prolog code for the partial evaluator for the flowchart language
   described in Ch. 4 of "Partial Evaluation and Automatic Program
   Generation" by Jones, Gomard and Sestoft is available for anonymous
   ftp from
      ftp.diku.dk:/pub/diku/dists/jones-book/ch4_pl.tar.Z
   All three Futamura projections are implemented. The code has been
   tested under SWI Prolog 1.5 and 1.7 and should hopefully port to other
   prologs without too many problems.  For more information, please
   contact Zerksis Umrigar <[e-mail]>.

Pleuk Grammar Development System:

   Pleuk is intended to be a shell for grammar development, in that many
   different grammatical formalisms can be embedded within it.
   Grammatical formalisms that currently work with Pleuk include CFG (a
   simple context-free grammar system), HPSG-PL (a system for developing
   HPSG-style grammars, produced at Simon Fraser University, Canada, by
   Fred Popowich, Sandi Kodric and Carl Vogel), Mike (a simple
   graph-based unification system, enhanced with additional operations
   for the treatment of free word order proposed by Mike Reape in various
   publications), SLE (a graph-based formalism enhanced with arbitrary
   relations in the manner of Johnson & Rosner and Doerre & Eisele.
   Delayed evaluation is used to compute infinite relations.  This system
   has been used for the development of several HPSG-style grammars) and
   Term (a term-based unification grammar system, originally developed
   for the support of Unification Categorial Grammar of Zeevat, Klein and
   Calder). Sample grammars are provided for all of these formalisms.
   Work continues apace on other formalisms, including Bob Carpenter's
   Ale system for typed feature structures, and Veronica Dahl's Static
   Discontinuity Grammars.

   Pleuk requires SICStus prolog version 2.1#6 or later, plus a variety
   of ancillary programs available free of charge from many FTP servers.
   Pleuk is available via anonymous FTP from the University of Georgia
   Artificial Intelligence FTP library
      ai.uga.edu:/pub/natural.language/
   as the files pleuk.1.0.tar.Z, pleuk.PSmanuals.tar.Z, and pleuk.README.
   Pleuk will also be available shortly from the Natural Language
   Software Registry, German Research Institute for Artificial
   Intelligence (DKFI), Saarbruecken.  For more information, send email
   to [e-mail].

Prolog Repository:
   Established by Jocelyn Paine of Experimental Psychology, Oxford
   University in 1987. The current catalogue (January 1991) contains
   30 entries. For catalogue, queries and contributions contact POPX at:
      [e-mail] (internet) or
      [e-mail] (janet)

   FTP access is available through the Imperial College archive at
      src.doc.ic.ac.uk:/packages/prolog-pd-software/  [146.169.2.10]
   This is actually a link to the directory
      /computing/programming/languages/prolog/pd-software/

   To access it, cd to either of the above directories via
   anonymous ftp. The file README gives a brief summary of the
   contents of the directory and CATALOGUE gives a (long!)
   description of each entry. Entries include the Logic Programming
   Tutor from Paine's book, the DEC-10 public-domain library, the
   Linger natural-language corrector, a simple object-oriented
   add-on for Prolog, graph utilities, among other things.

   Files in the archive are also available on MS-DOS floppies for a
   nominal fee to cover the cost of floppies, postage, and packing.

Prolog to SQL Compiler:
   The Prolog to SQL Compiler translates database access requests,
   which consist of a projection term and a database goal, to the
   appropriate SQL query. The compiler is written in standard Edinburgh
   Prolog and has been ported to a number of Prologs. The code posted to
   comp.lang.prolog works in ECRC's SEPIA Prolog, but should be easily
   ported to other Prologs. A detailed tech report on the implementation
   is available by email from [e-mail] (include
   your full postal address). The compiler is copyright, but may be used
   free of charge for non-commercial purposes and redistributed provided
   the copyright notice is retained intact.

PSI:
   PSI is a handy system for the management and retrieval of your
   personal data, be it addresses, CD collections, or bibliographic
   references. It is intended for the non-commercial user. It may not be
   as full-fledged as some data-base systems, but has some features that
   you won't find in most commercial systems. Also, you may find it
   easier to set up and faster to use. PSI is useful for a broad range of
   data. Indexing with descriptors makes searching for the data you need
   fast, and the interface to other data-base formats (import and export)
   is quite powerful. PSI was written in LPA MacProlog and is a "genuine
   'double clickable' Mac application". PSI runs on all Macs with System
   6 or 7 in 1MB of main memory. As LPA MacProlog isn't yet 32-bit clean,
   PSI isn't either. Extensive documentation and some examples are
   included. PSI is available by anonymous ftp from
   sumex-aim.stanford.edu:/info-mac/app/ as the file psi-23.hqx. It
   was also available on a recent Nautilus CD-ROM and will be on the
   first Info-Mac CD-ROM.

Queens and Knights:
   Queens and Knights are favorite problems for Prolog programmers.
   A collection of several implementations is available by anonymous
   ftp from sics.se:/pub/muse/queensANDknights.tar.Z.uue
   Write to Roland Karlsson <[e-mail]> for more information.

Rubik's Cube:
   Amzi! Inc., the creators of Cogent Prolog, have made sources to Cube Solver
   II available from their ftp site, ftp.std.com:/vendors/amzi/.  It is
   also available from the Prolog Repository at CMU, in
   ftp.cs.cmu.edu:/user/ai/lang/prolog/code/fun/rubik/.  This Prolog
   program solves Rubik's Cube.  The sources include a simple scrolling
   interface that should work in any Edinburgh standard Prolog.  Also
   included is a ready-made executable for 386 and 486 PCs; it was
   implemented using Cogent Prolog.  For more information, write to Amzi!
   Inc. (formerly Amziod) <[e-mail]>, 40 Samuel Prescott Dr.,
   Stow, MA 01775, Tel: [phone]. Fax: [phone].

SEL:
   SEL is a declarative set processing language. Its main features are
   subset and equational program clauses, pattern matching over sets,
   support for efficient iteration and point-wise/incremental computation
   over sets, the ability to define transitive closures through circular
   constraints, meta-programming and simple higher-order programming, and
   a modest user-interface including tracing. The language seems
   well-suited to a number of problems in graph theory, program analysis,
   and discrete mathematics. The SEL compiler is written in Quintus
   Prolog and the run-time system is written in C. It generates WAM-like
   code, extended to deal with set-matching, memoization, and the novel
   control structure of the language. SEL is available by anonymous FTP
   from ftp.cs.buffalo.edu:/users/bharat/SEL2/.  The FTP release comes with a
   user manual, bibliography of papers (including .dvi files), several
   sample programs, and source code. For further information, write to
   Bharat Jayaraman <[e-mail]>.

A public-domain WAM emulator, written in C++ by Herve Touati, is
available by anonymous FTP from gatekeeper.dec.com:/pub/plan/prolog/ucb/.

----------------------------------------------------------------
Subject: [1-6] Free Object-Oriented Systems for Prolog

OL(P), Object Layer for Prolog, is an object-oriented extension to
Prolog.  It provides an object-oriented structuring and reuse
mechanism for Prolog in a manner that preserves performance and
semantics. The object-oriented layer is compiled into Prolog without
introducing any side-effects.  OL(P) takes the view of objects as
collections of predicates (called methods).  To Prolog, OL(P) 1.1 adds
objects with methods, data encapsulation, instances, and multiple
inheritance. Object methods can access Prolog predicates and vice
versa. The OL(P) incremental compiler translates OL(P) programs to
Prolog programs that don't need runtime interpretation (e.g., no
search is needed for inheritance).  OL(P) 1.1 comes with prepared
installation for SICStus Prolog and QUINTUS Prolog (both on UNIX),
documentation, simple built-in project management, some libraries,
and example programs. The source is included, so you can port OL(P)
to different platforms, different Prolog systems, and different
logic programming languages. OL(P) is available by anonymous ftp
from parcftp.xerox.com:/ftp/pub/ol/ [13.1.64.94]. Written by Markus
P.J. Fromherz <[e-mail]>.

LogTalk is a free object oriented extension to the Prolog programming
language. It is based on a reflexive architecture intended to provide
an open system, easily tailored to user needs. It implements simple
inheritance and a delegation mechanism. Logtalk enables users to
define new types of slots, each one with its own semantics, that can
be reused by any object. It includes features for event-based
programming. This enables the creation of elegant solutions to
represent and maintain relations that restrict the internal state of
participating objects. Logtalk (and more information about it) is
available using the URL
   http://cygnus.ci.uc.pt/logtalk/logtalk.html
For more information, write to the author Paulo Moura <[e-mail]>.

See Common ESP (CESP) in [2-1] and BeBOP in [2-3].

----------------------------------------------------------------
Subject: [1-7] Commercial Object-Oriented Systems for Prolog

LAP is an object-oriented system by Elsa. For more information, write
to Elsa Software, La Grange Dame Rose, 6 ave du Marechal Juin, 92366
Meudon-La-Foret Cedex, France, call [phone], fax +33 (1)
46 30 55 26, or send email to elsa![e-mail].

SPIRAL is an object oriented system by CRIL for Sun3 and Sun4 under
Unix. For more information, write to CRIL, Conception et Realisation,
Industriel de Logiciel, 146 bd de Valmy 92707, Colombes Cedex, France,
call [phone], or fax [phone].

See also LPA Prolog ++ in [2-2].

----------------------------------------------------------------
Subject: [1-8]  The Prolog 1000 Database

The Prolog 1000 is a database of real Prolog applications being
assembled in conjunction with the Association for Logic Programming
(ALP) and PVG. The aim is to demonstrate how Prolog is being used in
the real world and it already contains over 500 programs with well
over 2 million lines of code. The database is available for research
use in SGML format from the Imperial College archive
   src.doc.ic.ac.uk:/packages/prolog-progs-db/prolog1000.v1.gz
If you have or know about a program that might qualify for inclusion,
send an email message to Al Roth ([e-mail]) for an
electronic entry form which only takes a few minutes to complete. Or
write to Prolog 1000, PO Box 137, Blackpool, Lancashire, FY2 0XY,
U.K., Fax: [phone] Telephone: [phone]. (Floppy disks for
PC or Mac in text form are also welcome, and paper entries may also be
sent). Queries may also be addressed to: Chris Moss
([e-mail]), Leon Sterling ([e-mail]).

----------------------------------------------------------------
Subject: [1-9] X-Windows Interfaces

PI:
   PI is an interface between Prolog applications and the X Window System
   that aims to be independent from the Prolog engine, provided that it
   has a Quintus-style foreign function interface (such as SICStus, YAP).
   It is mostly written in Prolog and is divided in two libraries: (1)
   Edipo, a low-level interface to the Xlib functions, and (2) Ytoolkit,
   a high-level user interface toolkit that allows you to create and
   manage graphical objects, define new classes of objects, and handle
   user interaction. PI is available by anonymous ftp from
   ftp.ncc.up.pt:/pub/prolog/pi_1.2.tar.gz and includes documentation
   and some demos. Also see ytoolkit.tar.Z. PI has been tested in
   Quintus Prolog 3.1.1 and SICStus 2.1 #8. Send questions, comments,
   and bug reports to Ze' Paulo Leal, Universidade de Porto, Portugal,
   <[e-mail]>.

XWIP:
   ftp.x.org:/contrib/xwip.tar.Z  (formerly export.lcs.mit.edu)
   ftp.uu.net:/X/contrib/xwip.tar.Z

   XWIP is an X Windows interface for PROLOG.

XPCE:
   XPCE is an object-oriented X-window interface toolkit for symbolic
   programming languages (Prolog and Lisp), offering a high level of
   abstraction for communication with X11, Unix processes, Unix
   networking facilities (sockets) and Unix files. XPCE's built-in
   classes (about 150) are mostly written in C.  The XPCE/Prolog
   interface allows the user to create and manipulate instances of these
   classes.  The user can also create new XPCE classes from Prolog.
   XPCE's window related classes provide various styles of menus,
   primitive graphical objects, compound graphical objects and Emacs
   oriented programmable text manipulation windows. The distribution
   contains several demo programs, including a diagram drawing tool
   (PceDraw), an animation demo, an Epoch-like editor, a graphical
   interface to Unix ispell, and an online hyper-text manual for XPCE
   itself.  A demo version of XPCE/SWI-Prolog for Linux may be obtained
   by anonymous ftp from swi.psy.uva.nl:/pub/xpce/linux/ [145.18.114.17].
   The non-demo versions (for SWI-Prolog, SICStus Prolog, Lucid Common
   Lisp and LispWorks) require filling out a license and paying a fee
   (see the file pub/xpce/INFO).  To be added to the mailing list
   [e-mail] send mail to [e-mail]. Send
   bugs to [e-mail].

   ProWindows 3 is a commercial version of XPCE for Quintus Prolog.
   For further information, write to Simon Heywood, AI International Ltd,
   The Chapel, Park View House, 1 Park View Road, Berkhamsted, Herts,
   HP4 3EY, phone [phone] (Sales Hotline [phone]),
   fax [phone], or send email to [e-mail].

ProTcl:

   ProTcl (pronounced pro-tickle) is a Prolog interface to Tcl/Tk. It has
   a very simple and lightweight interface, which allows one to evaluate
   Tcl expressions from Prolog. It defines the tcl_eval/1,2 predicate
   which passes the Tcl expressions to the Tcl interpreter. It has been
   tested on ECLiPSe and SICStus, on a Sparc 10. ProTcl is available
   by anonymous ftp from
      ftp.ecrc.de:/pub/eclipse/progs/protcl/
   The ProTCL home page is
      http://www.ecrc.de/eclipse/html/protcl.html
   Send comments and suggestions to Micha Meier <[e-mail]>.

----------------------------------------------------------------
Subject: [1-10] Is there a straight-forward way of compiling Prolog to C?

Two methods of compiling Prolog to C have been reported in the
literature:
   -  WAM-based approaches
   -  Continuation-based approaches

The WAM-based approach compiles Prolog programs into a sequence of C
function or macro calls to WAM instructions. A brief description of
this method and some results are given in the paper:

   Michael R. Levy and R. Nigel Horspool, "Translating Prolog to C: a
   WAM-based Approach", in Proceedings of the Second Compulog Network
   Area Meeting on Programming Languages, and the Workshop on Logic
   Languages in Pisa, May 1993. (Available by anonymous ftp from
   csr.uvic.ca:/pub/mlevy/.)

The best tutorial for writing a WAM-based compiler or WAM emulator is
Hassan Ait-Kaci's book, "Warren's Abstract Machine: A Tutorial
Reconstruction" (see [1-3] above).

A "quick-and-dirty" method is to implement the WAM functions as described
in Ait-Kaci's tutorial, to label each call with a C case label, and then throw
a giant switch(P) statement around the entire sequence of calls, where P
is the WAM program counter.  On return from any instruction that modifies
P, a "goto Start" must be inserted. (This method was posted by Rob
Scott, <[e-mail]>, based on the JANUS papers by Saraswat.)

This strategy will work, but does not allow you to modularize your
prolog program. Predicates in prolog seem to generate 8 to 15 WAM
instructions per clause, so (assuming very roughly a clause per
line)you might expect your 1,000 line program to expand to a switch
statement containing up to 15,000 lines. Some C compilers can't handle
such a big switch statement.

Levy and Horspool solve this problem by compiling each Prolog
predicate to a seperate C function. A dispatch loop mechanism is used
to call the C functions. C switch statements are used only inside the
functions.  A predicate that calls another predicate sets P to contain
the address of the C function that implements the called predicate,
(and sets another register called W in their scheme) and then returns
to the dispatcher instead of calling the predicate. This bypasses the
C run-time stack.  This lets one exploit WAM optimizations (like LCO)
and yet retain the ability to create many modules. Their system
performs well when compared with byte-code compilers, but translated
code runs slower than code produced by native code compilers.  On the
other hand, it outputs portable ANSI C that can run on any machine
with a C compiler.

Other approaches to translating to C use continuations. The idea here
is to translate every Prolog predicate to a C function that has
an additional argument, namely a continuation function. If the function
fails, it simply returns, but if it succeeds, it executes the continuation.
When the function regains control from the continuation, it can then try
to generate a new solution. Here are two references
that describe systems built using continuations:

   J. L. Weiner and S. Ramakrishnan, "A Piggy-Back Compiler for Prolog",
   in Proceedings of SIGPLAN T88 Conference on Programming Language
   Design and Implementation, Atlanta, Georgia, 1988, pages 288-296.

   J. L. Boyd and G. M. Karam, "Prolog in C", Carleton University,
   Ottawa, 1988.

Oliver Ridoux <[e-mail]> reports that a
continuation-based approach works well when used to compile
LambdaProlog. His scheme translates every predicate into a function
that uses and modifies the success and failure continuations, with
recursion in the predicate becoming iteration in the continuation
passing mechanism. Inside the function one uses whichever intermediate
machine one fancies. Clauses within the function can be either the
branches of a switch statement or simply labelled when using a C
system that can store labels. This approach can still generate
monstrous C programs that blow up the C compiler, but the C programs
aren't as large as those generated by a one module to a function
scheme. Approaches that replace recursion in a predicate with
recursion in a function tend to overload the C stack and lead to
sloppy memory management.  Two technical reports describing Ridoux's
approach are available by anonymous ftp from
   ftp.irisa.fr:/
as pm/*.ps.Z and mailv06/*.ps.Z.

Michael Covington <[e-mail]> points out that a very simple
approach is to write a Prolog interpreter in C, then store the Prolog
program in that program's data! This will, of course, execute slowly.
One might imagine all sorts of other schemes. For example, a query
could be treated as a stack of "suspensions" (with the left-most goal
on top).  The top suspension is executed by selecting the appropriate
clause (possibly using indexing), and then, if necessary, pushing new
suspensions on the stack (the body of the clause whose head unified
with the current suspension).

Another question to ask is this: Is there any reason why you should want to
convert Prolog to C at all? George Saab of Quintus Corp. pointed out that,
with Quintus Prolog, you can create a standard .o file from a Prolog file,
which can then be linked with your other .o files to create an executable.
What's more, your Prolog code can be called from C code and vice versa.

On ther hand, the advantage of distributing "Prolog objects" as C rather than
.o files is portability.

M. Gaspari  and G. Attardi describe an approach to translating Prolog to C
based on the provision of a common runtime architecture. This is
described in

   G. Attardi and M. Gaspari, "Multilanguage Interoperability", in
   Proceedings of The 3rd International Symposium, PLILP 91,
   Springer Verlag, LNCS #528, 1991.

[Note: Thanks to Michael Levy, Department of Computer Science,
University of Victoria, <[e-mail]>, for writing this section.]

----------------------------------------------------------------
Subject: [1-11] WAM emulators and tracers

Johan Bevemyr's Luther-based WAM-tracer is available by anonymous ftp
from Uppsala University in Sweden. It includes a simple compiler from
Prolog to WAM code and a low-level WAM code tracer written in
emacs-lisp.  The tracer splits the screen into regions to show
data-areas, registers, and so on. You can then step through running
the code. The tracer is available by anonymous ftp from
   ftp.csd.uu.se:/pub/WAM-tracer/luther.tar.Z
Documentation on the tracer is included in the distribution.  The
emulator is in the /pub/WAM-emulator/ directory (and runs in SICStus
Prolog).  For more information, contact Johan Bevemyr
<[e-mail]> or <[e-mail]>.

----------------------------------------------------------------
Subject: [1-12] What is the Basic Andorra Model and AKL?

The Basic Andorra Model is a way to execute definite clause programs
that allows dependent and-parallelism to be exploited transparently.
It also supports nice programming techniques for search programs.  The
idea is to first reduce all goals that match at most one clause.  When
no such goal exists, any goal (e.g., the left-most) may be chosen.
The BAM was proposed by David H. D. Warren, and his group at Bristol
has developed an AND-OR parallel implementation called Andorra-I,
which also supports full Prolog.  See, for example,

   Seif Haridi and Per Brand, "Andorra Prolog, an integration of Prolog
   and committed choice languages", in Proceedings of the FGCS 1988,
   ICOT, Tokyo, 1988.

   Vitor Santos Costa, David H. D. Warren, and Rong Yang, "Two papers on
   the Andorra-I engine and preprocessor", in Proceedings of the 8th
   ICLP. MIT Press, 1991.

   Steve Gregory and Rong Yang, "Parallel Constraint Solving in
   Andorra-I", in Proceedings of FGCS'92. ICOT, Tokyo, 1992.

AKL (Andorra Kernel Language) is a concurrent constraint programming
language that supports both Prolog-style programming and committed
choice programming.  Its control of don't-know nondeterminism is based
on the Andorra model, which has been generalised to also deal with
nondeterminism encapsulated in guards and aggregates (such as bagof)
in a concurrent setting. See, for example,

   Sverker Janson and Seif Haridi, "Programming Paradigms of the Andorra
   Kernel Language", in Proceedings of ILPS'91. MIT Press, 1991.

   Torkel Franzen, "Logical Aspects of the Andorra Kernel Language", SICS
   Research Report R91:12, Swedish Institute of Computer Science, 1991.

   Torkel Franzen, Seif Haridi, and Sverker Janson, "An Overview of the
   Andorra Kernel Language", In LNAI (LNCS) 596, Springer-Verlag, 1992.

   Sverker Janson, Johan Montelius, and Seif Haridi, "Ports for Objects
   in Concurrent Logic Programs", in Research Directions in Concurrent
   Object-Oriented Programming, MIT Press, 1993 (forthcoming).

The above papers on AKL are available by anonymous ftp from
   sics.se:/pub/ccp/papers/
An (as yet non-released) prototype implementation of AKL is available
for research purposes (contact [e-mail]).

----------------------------------------------------------------
Subject: [1-13] What is Constraint Logic Programming?

Constraint Logic Programming (CLP) augments Prolog by adding
constraints to the clauses. The CLP implementation solves goals in the
same manner as Prolog, but also merges the constraints associated with
each rule. If the merge succeeds, the successful goal and the
corresponding constraints are returned. If, however, the constraints
are mutually exclusive, the solution fails.

----------------------------------------------------------------
Subject: [1-14] How do you write portable programs in Prolog?

The de-facto standard syntax for Prolog is known as the Edinburgh
standard. It is based on the syntax of DEC-10 Prolog, an early Prolog
implementation developed at the University of Edinburgh.
See question [1-1] for information on the draft ISO standard for
Prolog.

Unfortunately, not every Prolog implementation is Edinburgh compatible.
There also isn't any notion of read-conditionalization, like #+ and #-
*features* in Common Lisp.

One option is to use the C preprocessor on Prolog code before loading
it into Prolog.  Or you could use term-expansion to roll your own
conditional compilation system. Term expanding a clause to []
effectively discards it.

Another possibility is to conditionalize the execution instead of the
compilation. The user would have to uncomment a line like one of the
following,
   % this_is(quintus).
   % this_is(sicstus).
and the code would have to test for the proper literal
   a :- this_is(quintus), blah, blah, blah.
   a :- this_is(sicstus), blah, blah, blah.
at a slight cost in efficiency. (If you first feed the program through
a general partial evaluator, you'll get an equivalent program without
the inefficiency. Partial evaluation is in some sense a more powerful
and semantically cleaner form of source preprocessing. Given
        <head> :- <condition>, <rest of body>.
If <condition> is always false, we can safely drop the clause. If
<condition> is always true, we can drop it from any clauses that
include it.)

Another possibility is Richard O'Keefe's environment package for
Prolog. It was posted to comp.lang.prolog on 1-SEP-94; a copy can be
found in
   ftp.cs.cmu.edu:/user/ai/lang/prolog/code/ext/env/env.pl

----------------------------------------------------------------
Subject: [1-15] World-Wide Web (WWW) Resources

The World Wide Web (WWW) is a hypermedia document that spans the
Internet.  It uses the http (HyperText Transfer Protocol) for the
light-weight exchange of files over the Internet.  NCSA Mosaic is a
World Wide Web browser developed at the National Center for
Supercomputing Applications (NCSA).

Mosaic's popularity derives, in part, from its ability to communicate
using more traditional Internet protocols like FTP, Gopher, WAIS, and
NNTP, in addition to http. Mosaic can display text, hypertext links,
and inlined graphics directly. When Mosaic encounters a file type it
can't handle internally, such as Postscript documents, mpeg movies,
sound files, and JPEG images, it uses an external viewer (or player)
like Ghostscript to handle the file. Mosaic also includes facilities
for exploring the Internet. In other words, Mosaic is an multimedia
interface to the Internet.

The hypertext documents viewed with Mosaic are written in HTML
(HyperText Markup Language), which is a subset of SGML (Standard
Generalized Markup Language).  All that is needed is just a few more
improvements, such as the ability to format tables and mathematics,
and a WYSIWYG editor, for HTML to greatly facilitate electronic
journals and other publications.

NCSA Mosaic for the X Window System is available by anonymous ftp from
   ftp.ncsa.uiuc.edu:/Mosaic/
as source code and binaries for Sun, SGI, IBM RS/6000, DEC Alpha OSF/1, DEC
Ultrix, and HP-UX. Questions about NCSA Mosaic should be directed to
[e-mail] (X-Windows version), [e-mail]
(Macintosh), and [e-mail] (Microsoft Windows).

An automatically generated HTML version of the PRG is accessible by
WWW as part of the AI-related FAQs Mosaic page. The URL for this
resource is
   http://www.cs.cmu.edu:8001/Web/Groups/AI/html/faqs/top.html
The direct URL for the PRG is
   http://www.cs.cmu.edu:8001/Web/Groups/AI/html/faqs/lang/prolog/prg/top.html

The remainder of this section lists WWW resources of interest to Prolog
and logic programming researchers, students, and practitioners.

Constraints:

   The newsgroup comp.constraints has an ftp archive and WWW home page:
      ftp.cs.city.ac.uk:/pub/constraints
      http://web.cs.city.ac.uk/archive/constraints/constraints.html

Logic Programming:

    http://www.comlab.ox.ac.uk/archive/logic-prog.html
    Jonathan Bowen <[e-mail]>

    http://www.watson.ibm.com/watson/logicpgm/
    [Logic Programming at IBM Research]
    Peter Reintjes <[e-mail]>

   http://ps-www.dfki.uni-sb.de/~vanroy/impltalk.html
   ["Issues in Implementing Logic Languages" -- overview of
    state-of-art in Prolog implementation.]
   Peter Van Roy <[e-mail]>

   http://www.informatik.uni-trier.de/~ley/db/index.html
   [Table of Contents from Conferences and Journals in the fields
    of database systems and logic programming.]
   Michael Ley <[e-mail]>

Abstract Interpretation for LP Bibliography:

   http://www.labri.u-bordeaux.fr/~corsini/Public/Reports/abint-biblio.ps
   200 entries so far.
   Marc-Michel Corsini <[e-mail]>

----------------------------------------------------------------
Subject: [1-16] Prolog Job Postings

The PROLOG-JOBS mailing list exists to help programmers find Prolog
programming positions, and to help companies with Prolog programming
positions find capable Prolog programmers. (Prolog here means Prolog-like
languages, including logic programming languages.)

Material appropriate for the list includes Prolog job announcements and
should be sent to [e-mail]. Resumes should NOT be sent to
the list.

[Note: The 'ai+' part of the mailing list name is used for directing
submissions to the appropriate mail-server. The list is NOT restricted
to AI-related Prolog jobs -- all Prolog job announcements are welcome.]

As a matter of policy, the contents of this mailing list is
considered confidential and will not be disclosed to anybody.

To subscribe, send a message to [e-mail] with
   subscribe prolog-jobs <First Name> <Last Name>, <Affiliation/Organization>
in the message body.

(If your mailer objects to the "+", send subscription requests to
"ai+query"@cs.cmu.edu, job announcements to "ai+prolog-jobs"@cs.cmu.edu,
etc.)

For help on using the query server, send mail to [e-mail] with
   help
in the message body.

Job postings sent to the list are automatically archived in
   ftp.cs.cmu.edu:/user/ai/jobs/prolog/

If you have any other questions, please send them to [e-mail]

----------------------------------------------------------------
Subject: [1-17] Is Prolog really used in Windows NT?

Yes.

For more information, see

   Dennis Merritt, "Extending C with Prolog", Dr Dobb's Journal,
   August 1994, pages 78-82 and 102, 104.

   D. Hovel, "Small Prolog and Windows NT Networking", Dr Dobb's Journal,
   August 1994, page 80.

----------------------------------------------------------------
Subject: [1-18] History of Prolog

Van Roy, Peter, "1983-1993: The Wonder Years of Sequential Prolog
Implementation," DEC Paris Research Laboratory, Research Report 36,
December 1993.

----------------------------------------------------------------
Subject: [1-A] Acknowledgements

The original version of this guide (Version 0.6, Dec 11, 1991) was
compiled by Dag Wahlberg, Uppsala University, Sweden
<[e-mail]>, and published in the 5(1) issue of the ALP
Newsletter (February 1992).  Other people who helped with the
compilation include Chris Moss <[e-mail]>, Mats Carlsson,
SICS <[e-mail]>, Michael A. Covington <[e-mail]>,
Jocelyn Paine <[e-mail]>, Per G. Bilse, PDC <[e-mail]>,
David Cohen, BIM Systems Inc <[e-mail]>, Mark Korsloot
<[e-mail]>, and David W. Talmage
<[e-mail]>.

Thanks also to Jamie Andrews <[e-mail]>.

----------------------------------------------------------------
;;; *EOF*
Path: senator-bedfellow.mit.edu!bloom-beacon.mit.edu!uhog.mit.edu!nntp.club.cc.cmu.edu!cantaloupe.srv.cs.cmu.edu!mkant
From: [e-mail] (Mark Kantrowitz)
Newsgroups: comp.lang.prolog,comp.object.logic,news.answers,comp.answers
Subject: FAQ: Prolog Implementations 2/2 [Monthly posting]
Supersedes: <[e-mail]>
Followup-To: poster
Date: 13 Mar 1995 08:03:00 GMT
Organization: School of Computer Science, Carnegie Mellon University
Lines: 1561
Approved: [e-mail]
Distribution: world
Expires: 24 Apr 1995 08:00:33 GMT
Message-ID: <[e-mail]>
References: <[e-mail]>
Reply-To: [e-mail]
NNTP-Posting-Host: glinda.oz.cs.cmu.edu
Xref: senator-bedfellow.mit.edu comp.lang.prolog:12371 comp.object.logic:389 news.answers:39807 comp.answers:10629

Archive-name: prolog/resource-guide/part2
Last-Modified: Thu Mar  9 15:25:48 1995 by Mark Kantrowitz
Version: 1.26
Maintainer: Mark Kantrowitz <[e-mail]>
URL: http://www.cs.cmu.edu:8001/Web/Groups/AI/html/faqs/lang/prolog/prg/top.html
Size: 85173 bytes, 1569 lines

;;; ****************************************************************
;;; Prolog Resource Guide ******************************************
;;; ****************************************************************
;;; prg_2.faq

This is part two of the Prolog Resource Guide. This part lists
available Prolog, logic programming, and constraint system
implementations, both free and commercial.

Send suggestions and comments to: [e-mail]

Prolog Implementations (Part 2):
  [2-0]  General information about Prolog Implementations

  [2-1]  Free Prolog Implementations
  [2-2]  Commercial Prolog Implementations

  [2-3]  Free Parallel Prolog Implementations
  [2-4]  Commercial Parallel Prolog Implementations

  [2-5]  Free Constraint Systems
  [2-6]  Commercial Constraint Systems

  [2-7]  Free Logic Programming Systems
  [2-8]  Commercial Logic Programming Systems

  [2-9]  Other Commercial Prolog Products

  [2-10] Prolog extensions, meta-interpreters, and pre-processors

Search for [#] to get to topic number # quickly. In newsreaders which
support digests (such as rn), [CTRL]-G will page through the answers.

----------------------------------------------------------------
Subject: [2-0] General information about Prolog Implementations

When comparing free and commercial Prolog implementations, a rule of
thumb is that commercial prolog implementations are often more robust
and better supported than the public domain and free prolog
implementations. Commercial Prolog implementations tend to have better
debugging facilities. Many of the commercial Prolog vendors offer
educational discounts to universities, and some of the commercial
Prolog implementations are rather inexpensive.

When considering a commercial Prolog implementation, be sure to ask
for current pricing information. Although we try to keep this
information up to date, there is no guarantee that it hasn't changed
in the interim. If you find that the information has changed, please
ask the vendor to send us current information.

Some research institutions make their Prolog implementations available
for a fee. We have included those implementations in the lists of
commercial Prolog implementations.

The Prolog Vendors' Group may be contacted by email via the Secretary,
Al Roth, at <[e-mail]>.

Remember when ftping compressed or compacted files (.Z, .arc, .fit,
.zip, .z, etc.) to use binary mode for retrieving the files.

Files that end with a .z suffix were compressed with the patent-free
gzip (no relation to zip). Source for gzip is available from:
   prep.ai.mit.edu:/pub/gnu/
as the files gzip-1.2.3.shar, gzip-1.2.3.tar,or gzip-1.2.3.msdos.exe.

----------------------------------------------------------------
Subject: [2-1] Free Prolog Implementations

The following list of free Prolog and logic programming implementations
excludes those listed in the comp.lang.lisp and comp.lang.scheme FAQs
(i.e., Prolog interpreters written in Lisp and Scheme).

Most of these Prolog implementations are available from the CMU AI
Repository, in the directory
   ftp.cs.cmu.edu:/user/ai/lang/prolog/impl/


A.D.A. Public Domain Prolog:
   aisun1.ai.uga.edu:ai.prolog/adapdpro.zip

   A rather slow implementation of Prolog for MS-DOS systems, originally
   a product of Automata Design Associates (now defunct), 1570
   Arran Way, Dresker, PA 19025, 215-335-5400.

Aquarius Prolog:
   Aquarius Prolog is a high-performance, portable Prolog implementation
   developed since 1989 by the Aquarius Project at UC/Berkeley, the Advanced
   Computer Architecture Laboratory (ACAL) at the University of Southern
   California (USC), and at Digital Equipment Corporation's Paris Research
   Laboratory. The developers are Tom Getzinger, Ralph Clarke Haygood, and
   Peter Van Roy. Aquarius Prolog includes:

      - A compiler with global analysis.  The compiler is built around the
        Berkeley Abstract Machine (BAM) execution model for Prolog. BAM
        retains desirable features of the Warren Abstract Machine (WAM),
        but allows for significant further optimizations and is easier to
        map onto actual general-purpose machines.

      - A back-end that maps the BAM onto various actual general-purpose
        machines, including MIPS R3000 (DEC Ultrix and MIPS RISC/os),
        SPARC (SunOS), HP 9000 300/400 with MC68020, MC68030 or MC68040
        processors (HP-UX), and Sun3 (SunOS).

      - A run-time system offering substantially the same built-in
        predicates and memory management as Quintus Prolog, with additions
        such as two kinds of destructive assignment.  Most of the built-in
        predicates are written in Prolog, with little or no performance
        penalty.

   Aquarius Prolog also includes an interpreter and documentation.
   Aquarius Prolog comes in two distributions, Enduser and Full. The
   latter includes full source code and implementation notes.

   Aquarius Prolog may be obtained free of charge from USC, after signing
   and returning a license agreement. To get the license agreement, send a
   message to [e-mail] with
      get aquarius-info license
   in the message body. To get more information about the Full and
   Enduser distributions, send the listserver a message containing
   one or both of the two lines:
           get aquarius-info readme-full
           get aquarius-info readme-enduser
   To subscribe to the aquarius-prolog mailing list, send the listserver a
   message with body:
           subscribe aquarius-prolog <Your real name here>
   To get more information about the abilities of the listserver, send it a
   message with 'help' in the body.

   For further information, write to University of Southern California,
   Advanced Computer Architecture Laboratory (ACAL), Attn: Aquarius Prolog
   Licensing, 3740 S. McClintock, Suite 131, Los Angeles, CA 90089-2561, or
   send email to [e-mail].

Beta-Prolog (version 1.2):

   Beta-Prolog is a fast and portable Prolog implementation. It consists
   of an emulator of the NTOAM (matching Tree Oriented Abstract Machine)
   written in C, a compiler written in Prolog that translates Prolog
   programs into NTOAM instructions, and a library of built-in
   predicates.

   Beta-Prolog has the following features:

      1. It is one of the fastest emulator-based Prolog implementations.
     The NTOAM inherits many good features of the WAM, but differs from
     WAM-based systems in that predicate arguments are passed directly
     in stack frames and only one frame is used for each predicate. For
     many programs written for WAM-based systems, Beta-Prolog is faster
     than emulator-based SICStus Prolog 2.1. Further speed-ups can be
     achieved if these programs are rewritten into a style suitable for
     Beta-Prolog by taking the NTOAM's argument passing scheme into
     account.

      2. Besides Edinburgh style clauses, Beta-Prolog also accepts
     matching clauses in which input and output unifications are
     separated, and determinism is denoted explicitly. The compiler is
     able to translate predicates in this form into matching trees and
     index them using all input arguments. The compiler can compile
     quite large programs in a short time because it consists of only
     matching clauses.

      3. It provides an interactive interface through which the
         programmers can consult, compile, load, debug and run programs.

      4. It provides an interface through which C functions can be
         called from Prolog.

      5. It provides a special data structure called state tables that
     can be used to represent graphs, simple and complex domains in
     constraint satisfaction problems, and situations in various
     combinatorial search problems.

      6. It includes a finite-domain constraint solver with which
         constraint satisfaction problems can be specified declaratively.

   Beta-Prolog is available by anonymous ftp from
      ftp.kyutech.ac.jp:/pub/Language/prolog/ [131.206.1.101]
   or from the CMU AI Repository in
      ftp.cs.cmu.edu:/user/ai/lang/prolog/impl/prolog/beta_pl/
   The system can be installed without difficulty on any machine that
   runs Unix and the cc (or gcc) C compiler. Beta-Prolog was developed by
   Neng-Fa Zhou, <[e-mail]>, Faculty of Computer Science
   and Systems Engineering, Kyushu Institute of Technology, 680-4 Kawazu,
   Iizuka, Fukuoka 820, Japan, phone [phone], fax [phone].
   For more information, send mail to [e-mail].

BinProlog:
   clement.info.umoncton.ca:/BinProlog3.0.tar.gz [139.103.16.2]
   ftp.elis.rug.ac.be:/pub/BinProlog/        [157.193.67.1]

   BinProlog replaces the WAM by a more compact continuation passing logic
   engine based on a mapping of full Prolog to binary logic programs.  It
   includes an interface Tcl/Tk. Version 2.20 runs on Sparc, DEC Alpha,
   MIPS (SGI, DEC) 68k (NeXT, Sun3), R6000 (IBM), PA-RISC (HP) and IBM PC
   (386/486). The compiler makes 528 KLIPS on a Sparc 10-40 (101 KLIPS on a
   NeXT) and still uses a very small (49K under Solaris 2.1) emulator,
   making it among the fastest freely available C-emulated Prologs (3-5
   times faster than C-Prolog, 2-3 times faster than SWI-Prolog, 1.5-2
   times faster than (X)SB-prolog and close to C-emulated Sicstus 2.1.).
   Comments and bug reports should be sent to Paul Tarau
   <[e-mail]>.

   BinProlog is free for reasearch and other non-profit purposes.  Use in
   industrial applications, licensing of C-sources, porting to other
   platforms, BinProlog related support and consulting are available but
   need a separate agreement. BinProlog's very small code-size and high
   performances make it suitable to be integrated in industrial
   C-applications that need the services of an embedded logic
   programming engine.

Boizumault Prolog:
   The various Prolog interpreters described in Patrice Boizumault's
   book, "The Implementation of Prolog", are available by anonymous
   ftp from
      cnam.cnam.fr:/pub/Boizumault/
   or from the CMU AI Repository in
      ftp.cs.cmu.edu:/user/ai/lang/prolog/impl/prolog/boiz_pl/
   The three interpreters, corresponding to appendices A through D of
   the book, are written in Common Lisp. Examples which run in all the
   interpreters include cryptarithms, Eliza, Sieve of Eratosthenes,
   Factorial, N-Queens, and Quicksort. For more information, write to
   Patrice Boizumault <[e-mail]>.

Common ESP:
   CESP (Common Extended Self-contained Prolog) is an object-oriented
   system by the AI Language Research Institute, Kamakura, Japan. The
   binary is free for R & D use only -- send 1/4in CMT Sun3 and Sun4
   (Sparc) with Sun OS R4.0.3, R4.1 or R4.1.1. For more information,
   write to AI Language Research Institute Ltd, Yoshitoku Bldg, Shiba
   3-15-14, Minato-Ku, Tokyo 105, Japan, fax [phone], or send
   email to [e-mail] or [e-mail].

cu-Prolog: See [2-5].

ECLiPSe (ECRC Logic Programming System) combines the functionalities
of several ECRC systems, including SEPIA (an Edinburgh-style
extensible Prolog system based on a WAM compiler), MegaLog (a database
system) and CHIP (a constraint logic programming system).  ECLiPSe
includes a Prolog compiler with extended functionality that is Quintus
and SICStus compatible, a tightly connected database system based on
the BANG file system, a CLP system, and an interface to the Tcl/Tk X11
toolkit. The BANG database can store not only relations, but also any
Prolog structures and programs. The CLP system contains several
libraries with various types of constraint handling schemes, including
atomic finite domains, linear rational constraints, CHR (constraint
handling rules) and Propia (generalised propagation).  It also
supports writing further extensions like new user-defined constraints
or complete new constraint solvers.  ECLiPSe also includes a profiler,
user-definable syntax, metaterms as first-class citizens, coroutining,
a high-level debugger (OPIUM), a partial evaluation system (PADDY),
and unlimited precision integer and rational numbers. ECLiPSe is
available for a nominal fee of DM 300 (~$200) to all academic and
government-sponsored organizations. It is distributed in binary form
for Sun-3 and Sparc machines. Send orders or requests for further
information to [e-mail] or write to ECRC,
Arabellastrasse 17, 81925 Munich, Germany. The ECLiPSe documentation
(ASCII and dvi) and some shareware packages ported to ECliPSe are now
available by anonymous ftp from
   ecrc.de:/pub/eclipse
To subscribe to the [e-mail] mailing list, send mail to
[e-mail]. The tech support email address is
[e-mail].

eLP (Ergo Lambda Prolog) is an interpreter written by Conal Elliott,
Frank Pfenning and Dale Miller in Common Lisp and implements the core
of lambda Prolog (higher-order hereditary Harrop formulas). It is
embedded in a larger development environment called ESS (the Ergo
Support System).  eLP implements all core language feature and offers
a module system, I/O, some facilities for tracing, error handling,
arithmetic, recursive top-levels, on-line documentation and a number
of extended examples, including many programs from Amy Felty's and
John Hannan's thesis.  It should run in Allegro Common Lisp, Lucid
Common Lisp, Kyoto Common Lisp, CMU Common Lisp and Ibuki Common Lisp.
The eLP implementation of lambda Prolog is no longer developed or
maintained, but it is still available via anonymous ftp from
ftp.cs.cmu.edu:/afs/cs.cmu.edu/project/ergo/export/ess/. The file
ergolisp.tar.Z contains the Ergo project's extensions to Common Lisp,
including some facilities for attributes and dealing with abstract
syntax trees. The file sb.tar.Z contains the Ergo
Parser/Unparser/Formatter generator and ab.tar.Z contains the Ergo
Attribute Grammar facility. The file elp.tar.Z contains the Ergo
implementation of lambda Prolog.  To customize grammars you need the
sb.tar.Z file.  When you retrieve the system, please print, fill out,
and send in a copy of the non-restrictive license you will find in the
file LICENSE. To subscribe to the [e-mail] mailing list, send
mail to [e-mail]. Bugs should be sent to
[e-mail].

ESL Prolog-2 (PD Version):
   ai.uga.edu:ai.prolog/eslpdpro.zip [128.192.12.9]

   A prolog for MS-DOS systems with good performance. It deviates
   slightly from Edinburgh standard (strings "like this" are not lists
   of ASCII codes), but you can add a declaration that makes it fully
   Edinburgh-compatible. (Add the line
        :- state(token_class,_,dec10).
   at the beginning of the program.) It is a more limited version
   of the interpreter from the Commercial Version (see [2-2] below).
   [Please note that ESL Prolog is NOT a UGA product, they just run
   the machine on which a copy is made available. Anyone with
   questions should contact ESL in Oxford, England (see [2-2] below).
   The commercial version of ESL Prolog-2 has been sold to ESI.]

   Documentation is available as a 2-volume set published by Ablex
   (type "prolog2" for info). ESL Prolog is also discussed
   extensively in Tony Dodd's book "Prolog: A Logical Approach,"
   Oxford University Press.

GOEDEL is intended to be a declarative successor to Prolog.  The main
design aim of Goedel is to have functionality and expressiveness
similar to Prolog, but to have greatly improved declarative semantics
compared with Prolog.  This improved declarative semantics has
substantial benefits for program construction, verification,
debugging, transformation, and so on. Considerable emphasis is placed
on Goedel's meta-logical facilities, since this is where Prolog is
most deficient.  In particular, Goedel has declarative replacements
for Prolog's var, nonvar, assert, and retract.  Goedel is a strongly
typed language, its type system being based on many-sorted logic with
parametric polymorphism. It has a module system, and supports floating
point numbers and infinite precision integers and rationals. It can
solve constraints over finite domains of integers and also linear
rational constraints. It supports processing of finite sets.  It also
has a flexible computation rule and a pruning operator which
generalises the commit of the concurrent logic programming languages.
The release includes the Goedel system, the SAGE partial evaluator for
Goedel, a user manual, and 50 example programs.  Goedel must be
compiled in SICStus Prolog 2.1 #6 or later; Sparc and Linux
executables are included in the distribution.  Goedel is available by
anonymous ftp from
   ftp.cs.kuleuven.ac.be:/pub/logic-prgm/goedel/ [134.58.41.2]
   ftp.cs.bris.ac.uk:/goedel [137.222.102.102]
For more information, write to [e-mail]. Please
send an email message to this address (with your name, institution and
address) to this address when you obtain the system. To subscribe to
the [e-mail] mailing list, send mail to
  [e-mail]
indicating that you wish to join the Goedel discussion group.
A book describing the language is now available from MIT Press:
   Patricia Hill and John Lloyd, "The Godel Programming Language",
   MIT Press, Cambridge, MA, 1994. ISBN 0-262-08229-2 ($45.00).

IC-Prolog II:
   src.doc.ic.ac.uk:/computing/programming/languages/prolog/icprolog/.
   The emulator is available at present only in Sun-4 binary form.
   Source code may be released later in the year when project
   finishes.

   Produced by Imperial College, IC-Prolog II is a multi-threaded
   Prolog system.  It includes a Parlog sub-system, an interface to
   TCP primitives and "mailboxes", a high level communication
   system.  These enable distributed applications (such as
   client/server systems) to be written using logic programming.
   The distribution also includes a simple expert system shell and
   the preprocessor for the Prolog language extension L&O from the
   book "Logic & Objects" by Frank McCabe.  (The sources for the
   L&O extension is also available to LPA MacProlog users in the
   subdirectory 'lo'.)

   See "I.C. Prolog II : a Multi-threaded Prolog System" by Damian
   Chu and Keith Clark and also "IC Prolog II: a Language for
   Implementing Multi-Agent Systems" by Damian Chu.  Postscript
   copies of these two papers may be found in the subdirectory
   'papers'.

   Standalone versions of the Parlog system for Sun-3 and Sun-4
   can also be found in this directory.

   Contact Damian Chu <[e-mail]> for questions about IC
   Prolog II, and contact Zacharias Bobolakis <[e-mail]> for
   information about L&O.

JB-Prolog 2.1.2 is a slim and powerfull prolog for the MacIntosh. Its key
features are: Arbitrary long integers, fast interpreter only, source
line debugger, user interface toolkit, persistent objects. It is
available from the CMU AI repository as
 ftp.cs.cmu.edu:/user/ai/lang/prolog/impl/prolog/jbprolog/JBprolog2.1.2.sit.hqx
For more information contact Jan Burse, [e-mail],
XLOG, Scheuchzerstr. 67, 8006 Zrich, Switzerland.

PIE2 is a Prolog interpreter for DOS. It is available on CompuServe in
the AIEXPERT forum. PIE2.zip contains the interpreter and examples, and
PIEDOC.ZIP contains the documentation. Written by Brent Ruggles
<[e-mail]>.

Prolog-68 is a free WAM-based Prolog system running on Atari ST and TT
computers. Not yet finished (no floating point, some missing
built-ins). Contact Jens Kilian <[e-mail]> for
information. Available by anonymous ftp from
   ftp.cs.cmu.edu:/user/ai/lang/prolog/impl/prolog/prolog68/
as a ZOO archive.

Prolog/Mali is a compiler for the higher-order language Lambda-Prolog.
Lambda-Prolog is an extension of Prolog defined by Miller (Miller,
D.A., and Nadathur, G., "Higher-order logic programming", 3rd
International Conference on Logic Programming, pages 448-462, London
1986). It is an extension of Prolog where terms are simply typed
lambda terms and clauses are higher order hereditary Harrop formulas.
The main novelties are universal quantification on goals and
implication.  Prolog/Mali is a complete system which includes a C
translator, a linker, libraries, runtime, and documentation, and runs
on UNIX.  It requires the MALI-V06 abstract memory package.
Prolog/Mali is available by anonymous ftp from ftp.irisa.fr:/pm/.
Written by Pascal Brisset <[e-mail]> (or <[e-mail]>)
and Olivier Ridoux ([e-mail]). To be added to the mailing list,
send mail to [e-mail]. For more information, send
mail to [e-mail].

LIFE (Logic, Inheritance, Functions, and Equations) is an experimental
programming language with a powerful facility for structured type
inheritance. It reconciles styles from functional programming, logic
programming, and object-oriented programming. It subsumes the
functionality of its precursor languages LOGIN and Le_Fun, and may be
seen as an extension of Prolog. The syntax of Wild_LIFE has been kept
as close as possible to that of the Edinburgh standard for Prolog.
LIFE offers natively high-level abstraction facilities and convenient
data and control structures particularly well-suited for AI
programming. LIFE implements a constraint logic programming language
with equality (unification) and entailment (matching) constraints over
order-sorted feature terms. The interplay of unification and matching
provides an implicit coroutining facility thanks to an automatic
suspension mechanism. This allows interleaving interpretation of
relational and functional expressions which specify structural
dependencies on objects. The Wild_LIFE interpreter is the first
implementation of the LIFE language available to the general public.
It is a product of Digital Equipment Corporation's Paris Research
Laboratory (DEC PRL). Wild_LIFE runs on MIPS/Ultrix (DECstations),
Alpha/OSF-1, SPARC/SunOS, RS/6000, and SGI machines, and should
be portable to other Unix workstations. It is implemented in C,
and includes an interface to X Windows. Wild_LIFE is available
by anonymous ftp from gatekeeper.dec.com:/pub/plan as the file
Life1.0.tar.Z. To be added to the mailing list ([e-mail]),
send mail to [e-mail]. Send bug reports to
[e-mail].

Open Prolog:
   Open Prolog (OP) is a Prolog interpreter for the Apple Macintosh.

   It follows the so-called 'Edinburgh' syntax and supports most standard
   Prolog features, including Definite Clause Grammars.
   Extra predicates can be added via drop-in external predicates, similar to
   Hypercard's XCMDs.

   OP will work in any Macintosh from a Plus upwards, and is now
   32-bit clean.

   OP is available by anonymous ftp from
      grattan.cs.tcd.ie:/languages/open-prolog/ [134.226.32.15]
   It is also available from other sites, such as:
      sumex-aim.stanford.edu:/info-mac/
      mac.archive.umich.edu [141.211.165.41]
      nexus.yorku.ca:/pub/prolog/  [130.63.9.1]
      aisun1.ai.uga.edu [128.192.12.9]
      /afs/umich.edu/group/itd/archive/mac/development/languages
   but the most recent version will always be available from
   grattan, OP's home site.

   For more information, write to Michael Brady, Computer Science
   Department, Trinity College, Dublin 2, IRELAND, send email to
   [e-mail], call [phone], or fax [phone] (5 hours
   ahead of East Coast US time).

PD Prolog 19:
   wuarchive.wustl.edu:/mirrors/msdos/prolog/prolog19.arc (IBM PC)
   aisun1.ai.uga.edu (128.192.12.9)

Portable Prolog System is an interpreter from the University of York.
Runs on any system having a Pascal compiler. For more information,
write to University of York, Software Distribution Officer, Department
of Computer Science, University of York, York, YO1 5DD, UK, call +44
(904) 59861, or fax [phone].

Qu-Prolog 3.2 and Ergo 4.0:

   Qu-Prolog is a high-level language designed primarily for rapid
   prototyping of interactive theorem provers and, more generally, for
   symbolic computation on formal languages.  Its object level includes
   quantified terms and object variables.  As an example, the interactive
   theorem prover Ergo 4.0 is implemented in Qu-Prolog.  The compactness
   and high level of Ergo 4.0 source code demonstrate the advantages of
   Qu-Prolog for such applications. Ergo includes a 'window inference'
   method that is specifically designed to support hierarchical
   goal-directed proofs and allow easy access to the context of a
   subterm. Ergo also provides support for defining a variety of logics
   and support for proving schematic theorems and answer extraction.
   Ergo is being used to support the development of verified software.
   The system has been tested only on a Sun4.
   Qu-Prolog and Ergo are available by anonymous ftp from
      ftp.cs.uq.oz.au:/pub/SVRC/
   as software/qp.tar.Z and software/Ergo.tar. The tech report
   techreports/tr93-18.ps.Z describes Qu-Prolog in detail. Send comments
   to Peter Robinson <[e-mail]>.

SB-Prolog:
   cs.arizona.edu:/sbprolog
   sbcs.sunysb.edu:/pub/sbprolog

   Stony Brook Prolog runs on Sun4, Pyramid-98x, DEC3100, SGI Iris,
   Amiga, and MS-DOS machines. Contact [e-mail] for more
   information. Two versions are available: version 2.5 is an
   interpreter for Amigas and version 3.1 is an interpreter and compiler
   for Unix and MSDOS/386.

   SB-Hilog runs in SB-Prolog and Quintus Prolog and is available on
      sbcs.sunysb.edu:/pub/hilog/

   src.doc.ic.ac.uk [146.169.2.10] contains SBProlog 3.1 executables for
   MS-DOS/386 in /computing/programming/languages/prolog/sbprolog,
   filename sbpmsdos.zip.

   nic.funet.fi contains SBProlog executables for Amiga in
   /pub/amiga/fish/disks100-199/ff140.

   Modular SB-Prolog (= SB-Prolog version 3.1 plus modules) is available
   by anonymous FTP from
      ftp.dcs.ed.ac.uk:/pub/dts/mod-prolog.tar.Z [129.215.160.5]
   Includes interpreter for SPARC. For more information, write to
   Brian Paxton <[e-mail]>.

   [NOTE: SB-Prolog is superseded by XSB (see below) and hence is
    no longer supported by Stony Brook or the University of Arizona.
    The only reason to continue using SB-Prolog is for DOS, since
    XSB does not run under DOS and there are currently no plans to
    port it to DOS.]

SLG:
   The SLG system is a meta interpreter implementation of
   goal-oriented deductive query processing and non-monotonic
   reasoning with the following features:
       * goal-oriented query evaluation of normal logic programs
         under the well-founded semantics by Van Gelder, Ross
         and Schliph;
       * goal-oriented query evaluation of general logic programs
         under the alternating fixpoint logic by Van Gelder, with
         the restriction that the body of a clause has to be either
         an existential conjunction of literals or a universal
         disjunction of literals.
       * goal-oriented query evaluation under the stable model semantics
         by Gelfond and Lifchitz.
       * integration with Prolog execution, and the use of Prolog syntax
         for all programs.
   The SLG system is freely available by anonymous ftp from Southern
   Methodist University or SUNY at Stony Brook
      seas.smu.edu:/pub/                 [129.119.3.2]
      sbcs.sunysb.edu:/pub/XSB/          [130.245.1.15]
   as the file slg.tar.gz. Comments, requests, and bug reports should
   be sent to Weidong Chen, <[e-mail]>, Computer Science and
   Engineering, Southern Methodist University, Dallas, Texas 75275-0122,
   phone [phone], or David Scott Warren, <[e-mail]>,
   Department of Computer Science, SUNY at Stony Brook, Stony Brook,
   NY 11794-4400, phone [phone].

SWI Prolog:
   swi.psy.uva.nl:/pub/SWI-Prolog/  [145.18.114.17] (Main source)
   as the files pl-1.9.tar.gz (sources), win-pl.zip (Windows 3.1 application),
   xos.tgz (DOS File I/O redefinition) and GNU readline
   [The patch level (last digit) is regularly updated and diffs between
   patch levels are located in the same directory.]
   mpii02999.ag2.mpi-sb.mpg.de:pub/tools/SWI/ [139.19.20.250] (OS/2)

   ftp.th-darmstadt.de:/pub/programming/languages/prolog/ [130.83.22.253]
   rs3.hrz.th-darmstadt.de  [130.83.55.75]

   SWI-Prolog includes a fast compiler, a profiler, C interface, a
   module system, libraries, and dynamic loading.
   Runs on Atari ST, Gould PN, NeXT, HP, IBM Linux, DEC MIPS, IBM
   PS/2 AIX, OS/2, IBM RS/6000, Sun3, Sun4, Sparc, and Vax.
   Written by Jan Wielemaker, SWI, University of Amsterdam,
   Roetersstraat 15, 1018 WB     Amsterdam, The Netherlands,
   <[e-mail]>. Ported to OS/2 by Andreas Toenne,
   <[e-mail]>. The mailing list is [e-mail].
   To be added to the list, send mail to [e-mail].

Toy Prolog is an interpreter written in Pascal. About 3500 lines of
source. Free with "Prolog for Programmers" by Kluzniak and Szpakowicz
(Academic Press 1985). The Atari ST version is no longer supported.

TPM (Transparent Prolog Machine) is a demo version of LPA MacProlog
with the TPM debugger included. Runs on Apple Macintosh. It is
available by anonymous FTP from hcrl.open.ac.uk:/pub/software/.

Tricia is a free Prolog high-level emulator with interpreter available
by email from Uppsala University. Tricia currently runs on the Apple
Macintosh. It used to run on Sun3, Sun4, Apollo DN-3500/4500/5500 (OS
version 10.*) and HP-730's, but support for those platforms has been
discontinued. For more information, write to Uppsala University,
Tricia project, Computing Science Department, Box 311, S-751 05
UPPSALA, Sweden, fax [phone], or email to
[e-mail]. It is available by anonymous ftp from
   ftp.csd.uu.se:/pub/Tricia/
A copy is also available in the directory
   /afs/umich.edu/group/itd/archive/mac/development/languages
if your site runs the Andrew File System, or by anonymous ftp from
mac.archive.umich.edu.

WAMCC 2.2 is a WAM-based Prolog to C compiler.  It conforms more or
less to the Edinburgh standard, and includes most of the usual
built-in predicates, a top-level, a Prolog debugger and a WAM
debugger. WAMCC is designed to be easily extended (see clp(FD) in
[2-5], for example). WAMCC's speed is halfway between SICStus emulated
and SICStus native code on a Sparc (1.5 times faster and 1.5 times
slower, respectively). WAMCC requires GCC 2.4.5 or higher and has been
tested on Sparc workstations. It should be easily ported to 32-bit
machines with GCC. WAMCC is available free by anonymous ftp from
   ftp.inria.fr:/INRIA/Projects/ChLoE/LOGIC_PROGRAMMING/wamcc/
For more information, write to Daniel Diaz <[e-mail]>,
INRIA Rocquencourt, FRANCE.

XSB is a Prolog-based Logic Programming System that extends the
standard functionality of Prolog with an implementation of OLDT
(tabling) and HiLog terms. It is a descendent of PSB-Prolog and
SB-Prolog. OLDT resolution is useful for recursive query computation,
allowing programs to terminate correctly in many cases where Prolog
does not. HiLog supports a type of higher-order programming in which
predicate symbols can be variable or structured.  This allows
unification to be performed on the predicate symbols themselves in
addition to the arguments of the predicates. XSB includes an
optimizing compiler, C interface, a module system, list processing
libraries, and dynamic loading.  XSB is a descendant of SB-Prolog.
XSB runs on Sun3, Sun4, 386/486 PCs (Linux and 386 BSD), SGI machines
(IRIX), HP 300/400 series (HP-UX) and NeXT, and can be compiled using
either the GNU C compiler or the Sun C compiler. Porting XSB to any
32-bit machine running Unix should be straightforward.  THIS IS A BETA
RELEASE. XSB is available by anonymous ftp from
   sbcs.sunysb.edu:/pub/XSB/XSB.tar.Z [130.245.1.15]
For more information, write to XSB Research Group, Computer Science
Department, SUNY at Stony Brook, Stony Brook, NY 11794, or send email to
[e-mail].

See also BeBOP and NCL in [2-3].

----------------------------------------------------------------
Subject: [2-2] Commercial Prolog Implementations

AAIS Full Control Prolog (version 3.1.3) is an Edinburgh-standard
compiler and interpreter that runs on all Apple 680x0 Macintosh computers
(from Plus through Quadras and Powerbooks). It runs under System 6
and 7 (or A/UX 3.0), requiring 4mb RAM, and is 32-bit clean.  It
is built on an object-oriented kernel, includes many object-oriented
extensions to the language, functions for constructing graphical user
interfaces, direct program access to the printer for printing text or
graphics, and full support for Apple Events. There are also numerous
example programs, including source code for the AAIS Full Control
Prolog's own standard development interface, and how to interface with
Oracle databases and FileMaker Pro databses.  AAIS Full Control Prolog
costs $495. For an additional $199 (and a signed license), you can get a
copy of AAIS Prolog Program Creator, an application generator/runtime
distribution system that turns Prolog programs into Macintosh
applications. For more information, write to Advanced AI Systems,
Inc., PO Box 39-0360, Mountain View, CA 94039-0360, call 415-948-8658,
fax [phone], or email [e-mail]. Earlier version (2.0)
reviewed in AI Expert, Feburary 1991.
   [NOTE: Douglas Lanam, President of Advanced AI Systems, Inc.,
   announced on April 1, 1994, that he would be ceasing all future
   development of the product due to economic and personal reasons. The
   remaining stock of AAIS Full Control Prolog and the Program Creator is
   being offered on an as-is basis with no return for $99 a copy. You
   can order copies by phone using your credit card.
   Technical support through phone, mail, and email is continuing, but
   they cannot return phone calls or faxes outside North America, so
   those replies would be sent by email or snail mail.]

AIAI Edinburgh Prolog is a high level prolog emulator that runs on
Acorn R140 (RISC iX), DG AViiON (DG/VX 4.1), Vax (Berkeley Unix, VMS),
Gould Encore (Unix), HP 9000/300 (HP-UX), MIPS RISC (RiscOS), Sequent
(DYNIX V3), Sun 2,3,4 (SunOS-3,4). For more information, write to
AIAI, AI Applications Institute, Software Secretary, University of
Edinburgh, 80 South Bridge, Edinburgh EH1 1HN, UK, call +44 (31) 650
2734, fax [phone], or send email to [e-mail].

ALS Prolog runs on 80386 machines, including DOS ($799), Sun 386i,
Xenix, Apple Macintosh ($499), System V Unix (Microport), Sun3, Sun4,
Sparc, Aviion, NeXT, VAX and Delta88. Workstation versions $4,500.
Student editions $59. Provides a superset of Edinburgh Prolog.  Includes
OOP, X Windows/Motif/Windows interface, and C interface (Prolog programs
may be embedded in C programs). It is available from Applied Logic
Systems, Inc., PO Box 180, Newton Centre, MA 02159, phone [phone],
fax [phone], or email [e-mail], [e-mail], or
[e-mail]. Send a message to [e-mail] with subject line "HELP"
to get a general information file in reply. The URL for their WWW site is
   http://www.als.com/
and their FTP site is frege.als.com.

Arity Prolog 6.1 is an emulator with interpreter and compiler and runs on
DOS ($650), OS/2 ($1k), Windows (extra $350), OS/2 V.2, and Windows-NT.
(Note that Windows support means that you can write Prolog programs that
manipulate Windows. The Windows version of Arity Prolog does not itself
run under MS Windows.) For more information, write to Arity Corporation,
Damonmill Square, Concord, MA 01742, call 800-722-7489 (508-371-1243),
fax [phone], or send email to [e-mail] or Paul G.
Weiss <[e-mail]>.

ProLog by BIM is a high-performance and robust implementation of the
Prolog language. It compiles to native machine code for maximum
execution speed, and provides flexible memory management with automated
expansion, shrinking, garbage collection and user-definable parameters.
The ProLog by BIM environment comprises a GUI including an execution
monitor and debugger, an on-line help facility, a extended emacs
interface and a profiler. ProLog by BIM also includes a bi-directional
external language interface, which is used for the included interfaces
to graphics, windowing and RDBMS packages. The system also comes with a
large library of Prolog source code which contains many of the most
commonly used predicates.  Stand-alone run-times without royalties and
embeddability allow problem-free end-user delivery.  ProLog by BIM comes
with Carmen, a WYSIWYG GUI-Generator delivering Prolog code that allows
notifiers and call-backs in Prolog and serves as a powerful
rapid-prototyping aid.  ProLog by BIM runs on SPARC, INTEL PC running
Solaris 2.x, HP700 and IBM RS/6000. BIM provides both training and
consultancy on Prolog and Prolog based developments efforts.  For more
information write to BIM sa/nv, ProLog by BIM dept., Kwikstraat 4,
B-3078 Everberg, Belgium, call [phone], fax to [phone]
(or [phone]) or email to [e-mail].

CIM-Prolog is a high-level emulator with interpreter for Apollo Domain
and Sun (Unix). Also Standard Prolog for Apollo Domain, IBM PC/AT (DOS),
INMOS transputer, and Sun. A parallel version is also available.
For more information, write to Creative Soft GmbH, Turnstrasse 10, D-8510
Fuerth, Germany, call [phone], or fax [phone].

Coder's Prolog 2.0 is a Prolog Interpreter from Austin Code Works. Works
on any system with a C compiler (it is designed for use with C
programs), including IBM PCs (MS-DOS) and Unix workstations. For
more information, write to Austin Code Works, 11100 Leafwood Lane,
Austin, TX 78750-3587, call 512-258-0785, fax [phone], or send
email to [e-mail].

Cogent Prolog 3.0 is an Edinburgh-standard compiler and interpreter.
Compiled and interpreted code may be intermixed in the same program (for
ease of debugging). The full system includes a debugger, definite clause
grammar support, full-screen shell, standard listener, support for
16-bit and 32-bit protected mode, linker, .exe generator and
royalty-free distributable runtime (DOS or Windows $248, both $347).
Compiler & interpreter without linker and distributable runtime ($149).
Interpreter alone ($49).  Also available is an interactive tutorial, the
Active Prolog Tutor ($75) and full source code for expert system shell
prototypes for forward/backward chaining, frames, Rete-network and more
($82).  All are IBM-PC (DOS) based. For more info or tech support, email
[e-mail], or contact Amzi! Inc., 40 Samuel Prescott Dr., Stow,
MA 01775. Tel: [phone]. Fax: [phone].

Delphia Prolog v2 is an Edinburgh-standard compiler and interpreter that
runs on Sun3, Sun4, Sparc, RS/6000, Apollo, HP9000/300, Unigraph 68xxx,
386/486 (SCO Unix), DecStation (Ultrix), Sony NEWS (Unix), VAX (VMS,
Ultrix), uVax (Ultrix), VaxStation (Ultrix). Includes database
interfaces, graphical libraries, and incremental compilation. Price
$10,000. Write to Delphia, 27 Avenue de la Republique, 38170 Seyssinet,
France, call 33-76-26-68-94 or fax [phone]. An earlier version
was reviewed in AI Expert, January 1991 and Feburary 1991.

ECRC SEPIA. See ECLiPSe. SEPIA is no longer delivered as a
stand-alone system, but as a part of ECLiPSe.

EDCAAD C-Prolog is a prolog interpreter for Sun (SunOS), VAX (Ultrix,
VMS), Apollo, and 68000 (Unix). An inexpensive academic license is
available. It is an interpreter-based system, and hence is slower than
WAM-based Prologs. It is implemented in C, and should run on almost
any 32-bit machine with a C compiler. For more information, write to
EdCAAD, Department of Architecture, Edinburgh University, 20 Chambers St.,
Edinburgh EH1 1JZ, UK, call [phone], fax [phone],
or send email to [e-mail].

FRIL (Fuzzy Relational Inference Language) is a logic-programming
language that incorporates a consistent method for handling
uncertainty, based on Baldwin's theories of support logic, mass
assignments, and evidential reasoning. Mass assignments give a
consistent way of manipulating fuzzy and probabilistic uncertainties,
enabling different forms of uncertainty to be integrated within a
single framework. Fril has a list-based syntax, similar to the early
micro-Prolog from LPA. Prolog is a special case of Fril, in which
programs involve no uncertainty. Fril runs on Unix, Macintosh, MS-DOS,
and Windows 3.1 platforms. For further information, write to Dr B.W.
Pilsworth, Fril Systems Ltd, Bristol Business Centre, Maggs House, 78
Queens Rd, Bristol BS8 1QX, UK. A longer description is available as
ftp.cs.cmu.edu:/user/ai/areas/fuzzy/com/fril.txt

GT-Prolog is a high performance implementation of Edinburgh-standard
Prolog for the Commodore Amiga. GT-Prolog includes the ProBench
interactive development environment supporting incremental compilation,
a multi-port debugger based on the Byrd model, a source code editor, and
a break facility. GT-Prolog provides transparent access to sophisticated
optimization techniques including Tail Recursion Optimisation, First
Argument Indexing/Hashing, In-line Arithmetic Evaluation and automatic
Garbage Collection of code and data. Error handling is based on catch
and throw mechanisms. GT-Prolog is also one of the first implementations
to support a fully logical Prolog database.  GT-Prolog provides explicit
control of memory allocation allowing programs to use up to 16mb for
data and 4gb for code and requires a minimum configuration of 1Mb memory
plus Workbench version 2 or later.  GT-Prolog includes a library of more
than 120 predicates that provide user programs with access to the
facilities of AmigaDOS. The single user price is 89.95 pounds sterling
inclusive of VAT and postage/packing. For more information, write to
Graham Thwaites, Grange Technology Limited, Stream Road, Upton, Didcot,
Oxon OX11 9JG, UK, tel/fax [phone], or send email to
[e-mail] or [e-mail].

HyperProlog. See Delphia Prolog.

IBM PROLOG for AIX/6000 (PFA) is a high performance implementation of
the PROLOG language, combined with a powerful programming environment,
especially designed for the IBM RISC System/6000 under AIX. PFA was
developed by BIM as an adaptation of ProLog by BIM for the IBM RISC
System/6000 under AIX. It was selected by IBM Europe as their
official PROLOG implementation for the RISC System/6000 (Program
Number 5776-FAH). For more information: In North-America contact BIM
systems, 11111 Santa Monica Bld, call 310-445-1500, fax to
[phone]; in Europe contact your local IBM representative.
Elsewhere contact BIM, Kwikstraat 4, B-3078 Everberg, Belgium, call
[phone], or fax [phone], or email [e-mail].

IF/Prolog 5.0 is a Prolog compiler with a variety of highly efficient
constraint problem solving tools, including Boolean constraints,
Rational terms, Linear terms, Equations and Inequations, Finite Domain
Constraints and Co-routines. IF/Prolog conforms to the ISO Prolog
Standard, part 1. IF/Prolog also includes interfaces to C, C++,
FORTRAN, X11 (OSF/Motif and Athena widgetsets), and SQL (Ingres,
Oracle, and Informix). IF/Prolog has full screen X11 and Windows based
debuggers and online hypertext help and quick reference guide.  It is
available on Unix, OSF/1, VMS, MS-Windows, and mainframe systems,
including Apollo, Aviion 300, Macintosh (A/UX), microVAX 2000
(Ultrix), Vax (Ultrix, VMS), VaxStation (Ultrix), DEC Alpha (OSF/1,
VMS), HP9000, Sun3, Sun4, Sparc, UTS, AIX/370, IBM RS/6000, Decstation
(Ultrix, OSF/1), Sequent S16, Silicon Graphics, Sony News (Unix),
Motorola, Nixdorf, Interactive Unix, SCO UNIX, DOS-based 386 PCs, and
Windows 3.0/3.1.  Academic licenses are available at half price.  For
more information contact Annette Kolb (marketing) or Dr. Andrew Verden
(technical) at IF Computer GmbH, Ludwig-Thoma-Weg 11a, D-82065
Baierbrunn, tel [phone], fax [phone], or email
[e-mail], or IF Computer Japan Ltd., 7/F 2nd Asanuma Bldg.,
3-21-10 Hongo, Bunkyo-ku, Tokyo 113, Japan.  tel + 81 3 3818 5826 fax
+ 81 3 3818 5829.

IQSOFT MProlog is a high-level emulator with interpreter for Unix,
Macintosh and IBM PC (DOS). Runs on Vax (Unix 4.2 BSD), 68000-based
machines (Unix), Tektronix 4404, HP3000, and Siemens 1. For more
information, write to IQSOFT, SZKI Intelligent Software Ltd., Iskola u.
10., Budapest, H-1011, Hungary, call [phone], fax [phone], or
send email to [e-mail].

LPA Prolog is a prolog compiler for IBM PCs (DOS, Windows, 386) and
Apple Macintosh. LPA Prolog++ is an object-oriented programming system
based on Prolog. (See Chris Moss's book on Prolog++ in [1-3].)
MacProlog32 includes incremental 32-bit compilation and Edinburgh syntax
compatability, and runs under System 7.  Programmer Edition is $745
list, and the Developer Edition, which includes a runtime generator for
producing standalone applications, is $1,495. LPA Prolog for Windows
runs $745, as does LPA Prolog for DOS. Prolog++ runs $995 ($1,995
Developer Edition). Write to Logic Programming Associates, Ltd., Studio
4, Royal Victoria Patriotic Building, Trinity Road, London SW18 3SX,
England, call [phone], fax [phone], or send email to
[e-mail] (sales, tech support), [e-mail]
(Clive Spenser), or [e-mail].  In the US call
800-949-7567.  LPA products are distributed in North America by Quintus
under the Quintus name.

Maxon Prolog is available for the Atari ST from the German magazine
'ST-Computer' for 298 DM. Tel: [phone].

MU-Prolog, NU-Prolog are prolog interpreters from the University of
Melbourne. Source licences are available for educational institutions.
Implemented in C for BSD Unix. Currently running on Sun3, Sun4, Vax,
Elxsi, Encore, and SGI. For more information, write to University of
Melbourne, MU-Prolog Distribution, Department of Computer Science,
Parkville, Victoria 3052, Australia, call [phone], or send email to
[e-mail] or [e-mail].

OU Prolog is a prolog interpreter from Open University for IBM PC
(MS-DOS). Includes video, books. Ask for item PD622 and quote
reference SA69. For more information, write to Open University,
Learning Materials Sales Office, PO Box 188, Milton Keynes MK7 6DH, UK.

PDC Prolog runs on IBM PCs (DOS, OS/2, Windows and SCO Unix). Formerly
known as Turbo Prolog from Borland. Includes a native code compiler
but is incompatible with most other prologs. Its variables are
strongly typed, unlike most other prologs. For more information, write
Prolog Development Center, 568 14th Street, Atlanta, GA 30318, call
800-762-2710, (404-873-1366), fax [phone] or email
[e-mail] (general information), [e-mail] (sales),
[e-mail] (tech support). A BBS is run at 404-872-5358. European
customers may write to Prolog Development Center, A/S, H.J. Holst Vej
5A, DK-2605 Broendby, Denmark, call [phone], or fax +45 36 72
02 69. Reviewed in AI Expert January 1991. Other email addresses
include [e-mail]. To subscribe to the
[e-mail] mailing list, a discussion list for PDC Prolog
users, send mail to [e-mail] with
    SUBSCRIBE PDC-L <your full name>
in the message body.

POPLOG is a high-level prolog emulator with interpreter for Unix. The POPLOG
environment integrates four AI programming languages in one
environment: Lisp, Prolog, ML and POP11. POPLOG can also load in C and
Fortran binaries. Runs on VAX (Ultrix, VMS), VAXStation (Ultrix),
DECStation (Ultrix), Sun 3,4, Sparc, Solbourne, HP Apollo 9000/400,
Sparc (HP-UX), MIPS (RISCOS), Sequent Symmetry (Dynix), Apple
Macintosh (AUX), SONY News (News-OS), and Silicon Graphics Iris
(Irix). The academic version from Sussex University. For more
information, write to POPLOG, Sussex University, Poplog Manager,
School of Cognitive Sciences, Falmer, Brighton BN1 9QN, UK, call +44
273 608367, fax [phone], or send email to [e-mail]
or [e-mail]. The commercial version is available
from Integral Solutions Ltd as Integral Poplog and Pop++. For more
information, write to Integral Solutions Ltd, Unit 3, 23 Campbell
Court, Bramley, Basingstoke Hampshire RG26 5EG, UK, call [phone]
28, fax [phone], or send email to [e-mail] or
[e-mail]. The North American retailer is Computable
Functions Inc. For more informatin, write to Computable Functions Inc.,
35 S. Orchard Drive, Amherst, MA 01002, call 413-253-7637, or fax
413-545-1249. Contact Robin Popplestone, [e-mail], for info
on a new book on Pop-11. There's a users mailing list, and a newsgroup
as well (comp.lang.pop).

Prolog-2 (Commercial Version), is a high-level emulator with
interpreter and compiler for IBM PC (MS-DOS, Windows 3.0/3.1), and
386-up. (Non-PC versions for Sun3, Sun4, HP9000 (Unix), RS/6000
(Unix), and VAX (VMS) are no longer supported, since ESI, the new
owners, are also distributors for BIM-Prolog.) It is an Edinburgh
standard prolog with a number of extensions. The windows version
includes BIPs for programming windows graphics and dialogues.  For
more information, write to Expert Systems International (ESI), Attn:
Leo Mulders, PO Box 148, NL-3700 AC ZEIST, the Netherlands, call
[phone], fax [phone], or email <[e-mail]>.  To join
the user's group, send mail to [e-mail].

Prolog III integrates constraint programming with Prolog. It runs on
Apple Macintosh, IBM PC (386, MS-DOS), Next, Sun3, Sun4, Sparc, HP9000,
Apollo, RS/6000, Bull DPX, Masscomp (Unix), Vax (Ultrix, VMS),
DecStation and MicroVAX. For more information, write to PrologIA,
Parc Technologique de Luminy, Case 919, 13288 Marseilles cedex 09, France,
call 33-91-26-86-36, fax [phone], or send email to
[e-mail] or [e-mail]. The US point of contact
for Prolog III by PrologIA is BIM Systems, Inc.

Prolog-86 is available from Solution Systems Inc. For more
information, write to Solution Systems Inc., 335-D Washington Street,
Norwell, MA 02061, call 617-337-6963, or fax [phone].

PTC (Prolog To C) is a portable Prolog compiler based around an
optimized Prolog to ANSI C compiler.  It runs on Sun, SGI, IBM (Unix),
and HP.  PTC includes an integrated compiler/interpreter,
project-file-based compilation, a Motif user interface, editor,
debugger, online help, and support for C modules. It costs $1,495 for
the development environment and $795 for each additional runtime
library. The standalone environment is $495. For more information,
write to Paralogic Inc., 115 Research Drive, Bethlehem, PA 18015,
call 215-861-6960, fax [phone] or send email to
[e-mail].

Quintec Prolog is a high-level emulator with interpreter for IBM PC
(MS-DOS), and Unix workstations such as Vax, VAXstation (Ultrix, VMS),
Decstation (Ultrix), and Sparc (SunOS4.0). For more information,
write to Quintec Prolog, Quintec Systems Ltd., Midland House, West Way,
Botley, Oxford OS2 0PL, UK, call [phone], or fax [phone].

Quintus Prolog is a complete Prolog development system with extensive
Prolog libraries, graphical user interface, source-linked debugger,
profiler, on-line help, interface to X Windows, and user-customizable
I/O and memory management.  Quintus Prolog supports development of
stand-alone applications, as well as fully embeddable Prolog modules,
which may be called as subroutines from other languages.  There are no
royalties on applications developed with Quintus Prolog.  Quintus
offers Prolog-based solutions for database, expert system, and GUI
developers. Quintus also provides Prolog consulting and Prolog
training.  Platforms include DEC Alpha (OSF/1), HP 9000 (HP-UX), IBM
RS/6000 (AIX), PC (DOS, Windows, Windows NT, Solaris, OS/2), Macintosh 32bit,
SGI (IRIX), Sun SPARC (SunOS, Solaris).  For product information and
Prolog training schedules contact Quintus Corporation, 301 East Evelyn
Avenue, Mountain View, CA 94041, call 415-254-2800 or 800-542-1283 (US),
fax [phone], or send email to [e-mail].  To be added to
the users group mailing list, email to [e-mail].
The email address for technical support is [e-mail].

SICStus Prolog:

   SICStus Prolog 2.1 is an Edinburgh compatible Prolog that runs on
   Macintosh, 386/486 (MSDOS), and most UNIX platforms. It includes a
   WAM-based emulator and compiler, native code compilation for Sparc and
   680x0, indexed interpreted and compiled predicates mixed arbitrarily,
   support for cyclic terms, garbage collection and stack shifting,
   backtrackable side-effects, coroutining facilities, exceptions, unbounded
   precision integer arithmetic, double precision floating point arithmetic,
   extended set of built-in arithmetic functions, a Boolean constraint solver,
   socket communication, support for building stand-alone applications,
   bidirectional C/Prolog interface, user-defined streams and signals, a GNU
   Emacs interface, execution profiling, a "procedure box" debugger, and a
   module system.  It comes with a library of utility modules implementing
   commonly needed algorithms and data types, an external store for Prolog
   facts with user-defined indexing, an object-oriented extension (SICStus
   Objects), and a package for GUI construction.

   Muse is an OR-parallel version of SICStus Prolog.  Muse runs on several
   multiprocessor platforms and supports full Prolog and most builtins.  The
   current version is a research version based on SICStus Prolog 0.6, but soon
   it will be integrated into the main SICStus Prolog release.

   Mixtus is an automatic partial evaluator for SICStus Prolog. Presently
   it is distributed separately. Contact [e-mail] for more information.

   Available third-party products include:

     +  APPEAL 2.1 (an interface and language to program X Toolkit
    applications, email: [e-mail], or write to: Cristina
    Ruggieri, DS logics S.r.l., Viale Silvani 1, 40122, Bologna, Italy,
    Tel. [phone], Fax. [phone])

     +  XPCE and PI X Windows interfaces (see [1-9])

     +  PRODATA (a tight coupling to Oracle, Ingres or Sybase relational
    database systems, write to: Keylink Computer Ltd., 2 Woodway House,
    Common Lane, Kenilworth, Warwickshire CV8 2ES, UK, Tel: [phone],
    Fax: [phone])

     +  NP Module (an interface to a highly efficient propositional
    logic theorem prover.  Contact: Logikkonsult NP AB,
        Jakobdalsv{gen 13, 126 53 H{gersten, Sweden.
        Tel: [phone], Fax: [phone] ).

   Personal, academic and commercial licenses are available.  More
   information is available on the WWW
      http://www.sics.se/ps/sicstus.html
   or by writing to SICS, Swedish Institute of Computer Science, PO Box 1263,
   S-164 28 KISTA, Sweden, calling [phone], fax [phone], or
   sending email to [e-mail] or [e-mail]. Bug reports
   and tech support questions should be sent to [e-mail].  To
   subscribe to the users group and implementors mailing list, send email
   to [e-mail].

SNI Prolog Version 3 is an implementation of the Prolog language that
is compatible with the ISO Standard draft. It is available from
Siemens Nixdorf for Unix workstations for about DM 11100 in Germany.
SNI Prolog runs on the SGI, SNI and Sun platforms, and ports to other
systems, including MS-DOS, are in progress. Includes coroutines,
finite domains, numerical and boolean constraints, garbage collection,
incremental compilation, dynamic linking, hypertext style on-line
help, a window environment with an integrated editor, interfaces to
INFORMIX, Motif/XWindows and C. The constraint programming features of
SNI Prolog provide support for solving problems from operations
research such as dynamic resource allocation and flexible scheduling
with numerical constraints or the verification of complex systems with
Boolean constraints. For more information, write to Siemens Nixdorf
Informationssysteme AG, Otto-Hahn-Ring 6, D-8000 Munich 83, Germany,
Attn: Hans-Juergen Stenger, Systems Planning, call [phone],
fax [phone], or send email to [e-mail].

SPIES YAP is a high-level emulator with interpreter for the Apple
Macintosh, Amiga (Atari ST), and Unix workstations including Sun3,
Sun4, VAXstation, SGI, and HP9000. For more information, write to
SPIES, Sociedade Portuguesa de, Importacao e Exportacao de Software,
Lda Av da Republica, 46 - 2, 1000 Lisboa, Portugal, call +351 1
795075, or fax [phone].

Turbo Prolog. See PDC Prolog.

XPRO 5.0 is a Prolog development environment for OS/2. It includes
a 32-bit Prolog interpreter/compiler and a rule compiler than compiles
natural language-style rules into Prolog code. Includes a C/C++
interface. Costs $299 (no runtime or license fees). For more
information, contact: Rational Vision, 7111 West Indian School Road,
Suite 131, Phoenix, AZ 85033, or phone [phone].


See also CHIP V4 from COSYTEC in [2-6].

----------------------------------------------------------------
Subject: [2-3] Free Parallel Prolog Implementations

This section contains free parallel Prolog and logic programming
implementations.

BAP:
   Brain Aid Prolog (BAP) is a Concurrent Sequential Processes (CSP)
   based standard Prolog for Transputer networks. BAP uses its own MS
   Windows or X Windows server for I/O. Special features include
   automatic topology adapation and concurrent source level debugging
   (see several processes exchange messages). Performance is pretty high,
   comparable to that of other Prolog compilers. BAP has achieved good
   results (>80% efficiency) when executing applications like N-queens or
   checkers in parallel on an 8 processor network. A demo version that
   supports Transputer systems with a maximum of 2 processors is
   available by anonymous ftp from
      unlisys.in-berlin.de:/pub/brainaid/
   and also from the CMU AI Repository, in
      ftp.cs.cmu.edu:/user/ai/lang/prolog/impl/parallel/bap/
   A full version for up to 128 nodes is also available for both SUN and
   PC. Write to Frank Bergmann <[e-mail]> or
   <[e-mail]> for more information.

BeBOP:
   The BeBOP language combines sequential and parallel Logic Programming
   (LP), object oriented programming and meta-level programming. The LP
   component offers both don't know non-determinism and stream AND
   parallelism, a combination not possible with concurrent LP languages.
   BeBOP's object oriented features include object IDs, encapsulation,
   message passing, state updating, and object behaviour modification.
   The meta-level capabilities are based on the treatment of Prolog
   theories as first order entities, which enables them to be updated
   easily and lets fragments to be passed between objects in messages.
   BeBOP is implemented by translation down to NU-Prolog, and its
   parallel extension, PNU-Prolog.  The BeBOP system (BeBOP and bp) and
   the PNU-Prolog preprocessor pnp can be obtained by anonymous ftp from
   munnari.oz.au:/pub/bebop.tar.Z [128.250.1.21].  The release comes with
   a user manual, several papers (in Postscript format), sample programs,
   and source code.  The BeBOP system requires the NU-Prolog system,
   compiler and interpreter, the pnp preprocessor (which is included as
   part of the BeBOP system release), GCC or a similar compiler, Yacc (or
   Bison) and Lex. For more information, contact Andrew Davison,
   <[e-mail]>, Dept. of Computer Science, University of Melbourne,
   Parkville, Victoria 3052, Australia, call [phone]/9101, or fax
   [phone].

KLIC:
   KLIC is a portable implementation of KL1 (an extended Flat GHC), a
   concurrent logic programming language developed at ICOT in Japan.
   Runs on Suns, HPs, DECs, and Linux PC's and marks 2 MLIPS on
   SparcStation 10/30 and 4MLIPS on system with 200MHz Alpha.  A
   sequential version available via anonymous ftp from ftp.icot.or.jp.
   Parallel versions planned shortly.  A representative paper on the
   language is Kazunori Ueda and Takashi Chikayama, "Design of the
   Kernel Language for the Parallel Inference Machine", The Computer
   Journal, December, 1990.  A paper on its KLIC implementation is
   Takashi Chikayama, Tetsuro Fujise and Daigo Sekita, "A Portable and
   Efficient Implementation of KL1", PLILP'94 (LNCS #844,
   Springer-Verlag).  For more information, send an email to
   [e-mail] or write to ICOT Free Software Desk,
   Institute for New Generation Computer Technology, 21st Floor, Mita
   Kokusai Bldg., 4-28, Mita 1-chome, Minato-ku, Tokyo 108, Japan, fax
   [phone].

Multi-BinProlog:
   Multi-BinProlog 2.00 is a prototype Linda-style parallel extension to
   BinProlog 1.71 developed by Koen De Bosschere and Paul Tarau. It uses
   Koen's C-parser and C-writer which together speed-up IO considerably.
   It works with shared-memory and remote procedure calls and is
   available from clement.info.umoncton.ca:MultiBinProlog/
   See BinProlog in [2-1] for more information.

NCL:
   NCL (Net-Clause Language) is aimed at describing distributed
   computation models using term unification as a basic processing and
   control mechanism. It is embedded in standard Prolog and comprises two
   parts -- net-clauses and data-driven rules, which can communicate each
   to other and to standard Prolog programs.  A net-clause is a special
   domain in the database defining a network of nodes and links. The
   nodes are represented by Prolog compound terms. The variables
   occurring within the nodes are global logical variables, which can be
   shared within the scope of the net-clause thus playing the role of
   network links.  Two control mechanisms are implemented: a spreading
   activation scheme similar to the connectionist spreading activation
   and to the marker passing mechanism in SN (in logic programming it is
   seen as a restricted forward chaining) and a default mechanism based
   on using variables to propagate terms without being bound to them,
   thus implementing the non-monotonicity of default reasoning.  The
   Data-driven Rules implement a full scale forward chaining for Horn
   clauses.  They simulate a data-driven parallel computation, where each
   rule is a process (in contrast to the traditional parallel logic
   programming where each goal is a process). The NCL/Prolog interpreter
   along with a reference manual and a set of examples is available by
   anonymous ftp at ai.uga.edu:/pub/misc/ncl.tar.Z. For more information
   contact Zdravko Markov, Institute of Informatics, Bulgarian Academy of
   Sciences Acad.G.Bonchev Street, Block 29A, 1113 Sofia, Bulgaria,
   <[e-mail]>.

PCN:
   PCN (Program Composition Notation) is not a logic programming
   language, but it has similarities to Strand and other concurrent logic
   programming languages. PCN is a parallel programming system that
   provides a simple language for specifying concurrent algorithms,
   interfaces to Fortran and C, a portable toolkit that allows
   applications to be developed on a workstation or small parallel
   computer and run unchanged on supercomputers, and integrated debugging
   and performance analysis tools. PCN includes a runtime system,
   compiler, linker, a set of standard libraries, virtual topology tools,
   a symbolic debugger (PDB), an execution profiler (Gauge), and a trace
   analysis tool (Upshot). PCN was developed at Argonne National
   Laboratory and the California Institute of Technology.  PCN runs on
   Sun4, NeXT, IBM RS/6000, SGI Iris, Intel iPSC/860, Intel Touchstone
   DELTA, Sequent Symmetry running Dynix (not PTX), and should be easy to
   port to other architectures. PCN is in the public domain and can be
   obtained by anonymous ftp from
      info.mcs.anl.gov:/pub/pcn/pcn_v2.0.tar.Z
   The distribution includes a user's guide containing a tutorial and
   reference material. For further information on PCN, please send email to
   <[e-mail]> or contact Ian Foster <[e-mail]>
   708-252-4619 or Steve Tuecke <[e-mail]> 708-252-8711.

ROLOG:
   ROLOG is a parallel PROLOG compiler with a reduce-OR process model.
   It is available by anonymous ftp from cs.uiuc.edu:/pub/ROLOG/.

See also IC-Prolog II (a multi-threaded Prolog) in [2-1].

----------------------------------------------------------------
Subject: [2-4] Commercial Parallel Prolog Implementations

This section contains commercial parallel Prolog and logic programming
implementations.

Densitron CS Prolog is a parallel prolog compiler and interpreter for
IBM PCs (MS-DOS or OS/2), T414/T800 transputer (mono or multi), 386
(Unix V), uVAX (VMS), or VAX(VMS). Also standard Prolog for MS-DOS,
UNIX and VAX. For more information, write to Densitron, Unit 4,
Aiport Trading Estate, Biggin Hill, Kent, TN16 3BW, UK, call +44 959
76331, or fax [phone].

Paralogic is a parallel implementation of the Clocksin and Mellish
Prolog. It runs on DOS-based PCs or Apple Macintoshes with the INMOS
Transputers. For more information, write to Paralogic Inc., 115
Research Drive, Bethlehem, PA 18015, call 215-861-6960, fax
215-861-8247 or email [e-mail]. It is also
distributed by Computer Systems Architects, 905 N. University Avenue,
Provo, UT 84604-3422, 800-753-4272 (801-374-2300), or fax [phone]
as n-parallel Prolog.

PARLOG is a parallel emulator from Imperial College for the Sequent
Balance, Sequent Symmetry, Encore Multimax, Alliant FX (Unix), Sun
(Unix, 1 processor). For more information, write to Imperial College,
Department of Computing, Parlog Distribution Secretary, 180 Queen's
Gate, London SW7 2BZ, UK, call [phone] x7537, fax [phone]
8024, or send email to [e-mail]. The single processor
versions of PARLOG for the Sun-3 and Sun-4 are now available free of
charge.  Please refer to the entry regarding IC-Prolog II in this
Resource Guide. Parallel Logic Programming produces PC-PARLOG and
MacPARLOG for the IBM PC and Macintosh computers.  For more
information contact Parallel Logic Programming Ltd., PO Box 49,
Twickenham, Middlesex TW2 5PH, UK or call [phone].

Strand-88 is a parallel emulator for Sun3, Sun4, Sparc BBN Butterfly,
GPT2000, Cogent Multimax, Intel iPSC/2, iPSC/860, MIPS RiscStation,
Sequent Symmetry Balance (Unix System V or Mach, Helios) and
communication component from CSTools, Express in some cases. Also
Transputer systems PC hosted systems from Paracom, Telmat and others,
Unix hosted systems from Meiko, Paracom, Telmat and others, Apple
Macintosh, Atari ATW, and NeXT. Price dependent on configuration and
scale of target machine. For more information, write to Strand
Software Technologies Ltd., Ver House, London Rd, Markyate, Herts AL3
8JP, UK, call [phone], fax [phone], or send email to
[e-mail].

SICS Aurora and Echo. See SICStus Prolog above.

----------------------------------------------------------------
Subject: [2-5] Free Constraint Systems

This section contains constraint systems, constraint logic programming
systems, concurrent constraint languages, and other constraint
processing systems.

CIAL:

   CIAL 1.0b is an interval constraint logic programming language. The main
   difference between CIAL and other CLP(Interval) languages is that a
   linear constraint solver, which is based on preconditioned interval
   Gauss-Seidel method, is embedded in CIAL in addition to the interval
   narrowing solver.

   The main motivations for a linear solver are:

      * Pure interval narrowing fails to narrow the intervals to any useful
    width even for such simple systems as {X+Y=5, X-Y=6}.  Interval
    splitting may help but is costly.

      * Pure interval narrowing cannot always detect inconsistency or halt
    (in a reasonable time).  A simple example is {A+1=D, A+B=D, A>0, B<0}.

      * Efficient linear constraint solver is also important to the study of
    efficient non-linear constraint-solving.  Recent results show that
    interval Newton method works better than pure interval narrowing for
    solving non-linear constraints, but may require to solve many linear
    constraints in order to give the best results.

   This version of CIAL prototype is implemented as an extension to CLP(R)
   v1.2 and tested on Sun Sparc machines. You should have obtained CLP(R)
   from IBM prior to installing CIAL. The distribution is in the form of
   patches to the CLP(R) sources. [See entry on CLP(R) below].
   Send email to [e-mail] to request CIAL, and for more details.

   Relevant papers include

      C.K. Chiu and J.H.M. Lee, "Towards practical interval constraint solving
      in logic programming", in Proceedings of the Eleventh International
      Logic Programming Symposium, Ithaca, NY, USA, November 1994 (to appear).

      J.H.M. Lee and T.W. Lee, "A WAM-based abstract machine for interval
      constraint logic programming and the multiple-trailing problem", in
      Proceedings Sixth IEEE International Conference on Tools with
      Artificial Intelligence, New Orleans, Nov 1994.

cu-Prolog:
   cu-Prolog is an experimental constraint logic programming language
   available free from Japan's Institute for New Generation Computer
   Technology (ICOT). Unlike most conventional CLP systems, cu-Prolog
   allows user-defined predicates as constraints and is suitable for
   implementing a natural language processing system based on the
   unification-based grammar. For example, the cu-Prolog developers
   implemented a JPSG (Japanese Phrase Structure Grammar) parser in
   cu-Prolog with the JPSG Working Group (the chairman is Prof. GUNJI,
   Takao of Osaka University) at ICOT. cu-Prolog is a complete
   implementation of Constraint Unification (cu), hence the name.
   cu-Prolog is implemented in C for BSD UNIX 4.2/3. Professor Sirai of
   Chukyo-University has also implemented cu-Prolog for the Apple
   Macintosh and DJ's GPP (80386/486 MS-DOS machine with the DOS
   extender). cu-Prolog is available free by anonymous ftp from
   ftp.icot.or.jp. For further information, send email to [e-mail],
   or write to ICOT Free Software Desk, Institute for New Generation
   Computer Technology, 21st Floor, Mita Kokusai Bldg., 4-28, Mita
   1-chome, Minato-ku, Tokyo 108, Japan, fax [phone].

clp(FD):
   clp(FD) 2.2 is a constraint logic programming language over finite
   domains and booleans based on the wamcc Prolog compiler (see [2-1]).
   clp(FD) provides several constraints "a la CHIP" on finite domains and
   booleans and some facilities for building new constraints. clp(FD) is
   4 times faster than CHIP v3.2 on average.  clp(FD) requires GCC 2.4.5
   or higher and has been tested on Sparc workstations, DEC (Ultrix),
   Sony MIPS (R3000), and 386/486 PCs under linux. It should be
   easily ported to 32-bit machines with GCC.  clp(FD) is available free
   by anonymous ftp from
      ftp.inria.fr:/INRIA/Projects/ChLoE/LOGIC_PROGRAMMING/clp_fd/
   For more information, write to Daniel Diaz <[e-mail]>,
   INRIA Rocquencourt, FRANCE.

CLP(R):
   CLP(R) is a constraint logic programming language with real-arithmetic
   constraints.  The implementation contains a built-in constraint solver
   which deals with linear arithmetic and contains a mechanism for delaying
   nonlinear constraints until they become linear.  Since CLP(R) subsumes
   PROLOG, the system is also usable as a general-purpose logic programming
   language. It includes facilities for meta-programming with constraints.
   The system consists of a compiler, byte-code emulator, and constraint
   solver. CLP(R) is written entirely in C and runs on Suns, Vaxen,
   MIPS-based machines (Decstations, Silicon Graphics), IBM RS6000s and
   PS2s. Includes MS-DOS support. It is available free from IBM for
   academic and research purposes only. To get a copy, write
   to Joxan Jaffar, H1-D48, IBM Thomas J. Watson Research Center,
   P.O. Box 704, Yorktown Heights, NY 10598, or send email to
   [e-mail] or [e-mail]. Current version 1.2.
   For more information, write to Joxan or Roland Yap
   <[e-mail]>.

OZ:
   Oz is a concurrent constraint programming language designed for
   applications that require complex symbolic computations, organization
   into multiple agents, and soft real-time control.  It is based on a
   computation model that provides a uniform foundation for higher-order
   functional programming, constraint logic programming, and concurrent
   objects with multiple inheritance.  From functional languages Oz
   inherits full compositionality, and from logic languages Oz inherits
   logic variables and constraints (including feature and finite domain
   constraints). Search in Oz is encapsulated (no backtracking) and
   includes one, best and all solution strategies.

   DFKI Oz is an interactive implementation of Oz featuring a programming
   interface based on GNU Emacs, a concurrent browser, an object-oriented
   interface to Tcl/Tk, powerful interoperability features (sockets, C,
   C++), an incremental compiler, a garbage collector, and support for
   stand-alone applications.  Performance is competitive with commercial
   Prolog and Lisp systems.  DFKI Oz is available for many platforms
   running Unix/X, including Sparcs and 486 PCs.

   Applications DFKI Oz has already been used for include simulations,
   multi-agent systems, natural language processing, virtual reality,
   graphical user interfaces, scheduling, placement problems, and
   configuration.

   Version 1.0 of DFKI Oz has been released on January 23, 1995.  DFKI Oz
   is available by anonymous ftp from
      ps-ftp.dfki.uni-sb.de:/pub/oz
   or through the WWW from
      http://ps-www.dfki.uni-sb.de/
   Tutorials, reference manuals, and research papers are available from
   the same locations.  You may start with "A Survey of Oz" (8 pages) and
   continue with "An Oz Primer" (110 pages). Questions may be directed to
   [e-mail]. To join the Oz users mailing list, contact
   [e-mail].

See also ECLiPSe, Beta-Prolog, and LIFE in [2-1] and ALE in [1-5].

----------------------------------------------------------------
Subject: [2-6] Commercial Constraint Systems

This section contains constraint systems, constraint logic programming
systems, concurrent constraint languages, and other constraint
processing systems.

CHIP V4 (Constraint Handling In Prolog) is designed as an extension to
Prolog offering three constraint solving domains: Integers, Rationals
and Booleans. The system was originally developed at ECRC in Munich
and now extended by the same team at COSYTEC in Paris. CHIP V4
includes extensions to the three domains: symbolic constraints, update
demons and cumulative constraints. The system is available with
optional interfaces for X11 and DOS graphics (XGIP), Oracle or Ingres
database connection (QUIC), C language interface (CLIC) and embedded
application interface (EMC). CHIP V4 is written completely in C, and
is available on a range of workstations including SunSparc (SunOS
4.1), IBM RS6000 (AIX 3.2), HP 9000/700 series (HPUX 9.0) and
Decstation 3000 & 5000 (Ultrix 4.2) and PC386/486 (Dos 5.0).
Development and Runtime licences can be purchased for single-user,
multi-user or site licences together with support and maintenance. An
academic discount is offered for educational and research purposes.
For more information contact COSYTEC, Parc Club Orsay Universite 4 rue
Jean Rostand, 91893 Orsay Cedex, France, phone [phone], fax
[phone] or email <[e-mail]>.  The Tech Support
email address is [e-mail]. COSYTEC is a founding
member of the PVG (Prolog Vendors Group).

CLP(R) is a constraint system from Monash University for VAX, Sun, and
Pyramid (Unix). Costs $150. For more information, write to Monash
University, CLP(R) Distribution, Department of Computer Science,
Clayton, Victoria 3168, Australia, or send email to
[e-mail].

ILOG SOLVER (formerly called PECOS) is a C++ library that implements a
CLP (Constraint Logic Programming) instance known as finite domains.
It is available on most Unix platforms, including Sun, HP, IBM
RS-6000, DEC, and SGI, and on Windows 3.1 for both Microsoft Visual
C++ and Borland C++. This library includes:
  - Prolog control structures:  non determinism, choice points,
    backtracking and cut. Modification of user-defined objects can be
    trailed so that their state is restored when a failure occurs.
  - Finite domain logical variables, and associated constraints.
  - Finite set logical variables and associated constraints.
  - Interval floating point variables, and associated
    constraints, analogous to what is found in BNR Prolog.
  - Predefined search and optimization algorithms.
ILOG SOLVER does not use unification for passing arguments.  This
enables a smooth integration with C++. For further information: In the
USA and Canada, contact ILOG, Inc., 2073 Landings Drive, Mountain
View, CA 94303, phone [phone], fax [phone], e-mail
[e-mail].  Outside the USA and Canada: contact ILOG SA, 12 avenue
Raspail, 94251 Gentilly Cedex, France, tel [phone],
fax [phone], e-mail [e-mail], or URL
   http://www.ilog.fr/ilog/home.html
See also http://www.ilog.fr for some papers about Ilog Solver and Ilog
Schedule.

VS Trilogy is a Prolog compiler available from Vertical Software for
$395. For more information, write to Vertical Software Ltd., 14-636
Clyde Ave, W. Vancouver, BC, V7T 1E1, Canada, call 604-925-0321, or fax
604-688-8479.

See also Prolog III and SNI Prolog in [2-2].

----------------------------------------------------------------
Subject: [2-7] Free Logic Programming Systems

ALF:
   ALF (Algebraic Logic Functional programming language) is a
   language which combines functional and logic programming techniques.
   The foundation of ALF is Horn clause logic with equality which
   consists of predicates and Horn clauses for logic programming, and
   functions and equations for functional programming.  The abstract
   machine is based on the Warren Abstract Machine (WAM) with several
   extensions to implement narrowing and rewriting.     In the current
   implementation programs of this abstract machine are executed by an
   emulator written in C. It is available by anonymous ftp from
      ftp.germany.eu.net:/pub/programming/languages/LogicFunctional/
   (aka simpson.germany.eu.net) as the files alf_*.zoo
   (Documentation, C sources for the emulator, the preprocessor and the
   compiler). For further information, contact Rudolf Opalla
   <[e-mail]>.

CORAL:
   CORAL is a deductive database/logic programming system developed at
   the University of Wisconsin-Madison. It is a declarative language
   based on Horn-clause rules with extensions like SQL's group-by and
   aggregation operators, and uses a Prolog-like syntax.

   CORAL is available via anonymous ftp from ftp.cs.wisc.edu:/coral/.  The
   distribution includes source code compatible with AT&T C++ Version 2.0
   or later, executables for Decstations and SUN 4s, the CORAL User
   Manual, and some related papers containing a language overview and
   implementation details.  (A version of the source code compatible with
   GNU g++ will be available shortly.) For more information, contact
   Raghu Ramakrishnan, <[e-mail]>.

Lolli:
   Lolli is an interpreter for logic programming based on linear logic
   principles. Lolli, named for the linear logic implication operator
   "-o" called lollipop, is a full implementation of the language
   described in the paper "Logic Programming in a Fragment of
   Intuitionistic Linear Logic" (Josh Hodas & Dale Miller, to appear in
   Information and Computation), though it differs a bit in syntax, and
   has several built-in extra-logical predicates and operators. Lolli is
   available by anonymous ftp from
      ftp.cis.upenn.edu:/pub/Lolli/Lolli-07.tar.Z
   This distribution includes full ML source, along with a Makefile, as well
   as several background papers and a collection of example programs. For
   those who do not have SML-NJ at their site, the authors hope to
   provide pre-built binaries for a variety of architectures. These
   binaries can be found on
      ftp.cis.upenn.edu:/pub/Lolli/binaries/
   At present Sparc and NeXT binaries are available.  If you compile
   lolli on a new architecture, please contact Josh Hodas at
   <[e-mail]> so that he can make your binary available.

See also LIFE, SLG, and XSB in [2-1], BeBOP in [2-3], and Oz in [2-5].

----------------------------------------------------------------
Subject: [2-8] Commercial Logic Programming Systems

None so far. This is to be expected, as most logic programming systems
are experimental.

----------------------------------------------------------------
Subject: [2-9] Other Commercial Prolog Products

ClauseDB is a database manager for Prolog data.  Advanced
knowledge-based applications often need to use a large number of
highly complex data objects. The objects are so complex that they
cannot be managed in a standard commercial RDB product, and the number
of them makes it impractical to store them in the standard Prolog
in-memory database. ClauseDB may also be useful even in Prolog
applications whose data can be handled in a RDB. The retrieval
procedure of ClauseDB is integrated in the Prolog search method. This
avoids the performance problems that arise with the standard scheme
for coupling Prolog with a RDBM (e.g., those caused by the well-known
mismatch problem between tuple- and set-based retrieval methods).
ClauseDB supports all the normal Prolog data objects (arbitrary terms
and clauses) and provides a locking mechanism that allows the sharing
of data while ensuring its integrity. ClauseDB 2.0 is available on
SUN SPARC (SunOS 4.x and 5.x) and the INTEL PC running Solaris 2.x.
For more information write to BIM sa/nv, ProLog by BIM dept.,
Kwikstraat 4, B - 3078 Everberg, Belgium, call ++32 2 759 59 25, fax
to [phone] or e-mail to [e-mail].

----------------------------------------------------------------
Subject: [2-10] Prolog extensions, meta-interpreters, and pre-processors

ProFIT (Prolog with Features Inheritance and Templates) is an extension
of Prolog with sorted feature structures (including multi-dimensional
inheritance), finite domains, feature search, cyclic terms, and
templates. ProFIT works as a pre-processor, which takes a file
containing a ProFIT program as input, and gives a file with a Prolog
program as output. Sorted feature terms and finite domains are
compiled into a Prolog term representation, and the usual Prolog term
unification is used at runtime, so that there is no slowdown through a
unification algorithm, and no meta-interpreter is needed. ProFIT uses
the same techniques for compiling sorted feature terms and finite
domains into Prolog terms as the Core Langauge Engine of SRI Cambridge
and the Advanced Linguistic Engineering Platform (ALEP 2.2) by the
European Community, BIM, and Cray Systems. ProFIT is not a grammar
formalism (although it is motivated by NLP), although it provides some
ingredients that are considered typical of grammar formalisms. The goal
of ProFIT is to provide these datatypes without enforcing any
particular theory of grammar, parsing or generation. ProFIT can be used
to extend your favourite Prolog-based grammar formalism, parser and
generator with the expressive power of sorted feature terms. Cyclic
terms can be printed out and a user-configurable pretty-printer for
feature terms is provided. ProFIT is available free of charge by
anonymous ftp from
   coli.uni-sb.de:/pub/profit/
and is implemented in Sicstus Prolog (2.1 #9). For more information,
write to Gregor Erbach, Univ. Saarlandes, Saarbruecken, Germany
<[e-mail]> <http://coli.uni-sb.de/~erbach>.

----------------------------------------------------------------
;;; *EOF*